diff --git a/Directory.Build.props b/Directory.Build.props
index 3dd057f702b..e8e24051b1d 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -6,6 +6,7 @@
     <AccelerateBuildsInVisualStudio>true</AccelerateBuildsInVisualStudio>
     <FSharpNetCoreProductDefaultTargetFramework>net8.0</FSharpNetCoreProductDefaultTargetFramework>
   </PropertyGroup>
+
   <!--
    When developers load the FSharp.Compiler.Service solution we set FSHARPCORE_USE_PACKAGE to true if it hasn't already been set to a value.
    This option ensures that building and testing uses the specified FSharp.Core nuget package instead of the local FSharp.Core project.
@@ -20,6 +21,19 @@
   <PropertyGroup Condition="'$(BUILDING_USING_DOTNET)' != 'false' and '$(DotnetProjInfo)' == 'true'">
       <BUILDING_USING_DOTNET>true</BUILDING_USING_DOTNET>
   </PropertyGroup>
+  
+  <PropertyGroup Condition="'$(BUILDING_USING_DOTNET)' != 'true'">
+    <!--
+         When shipping Build fsharp.compiler.service dll using realsig visibility
+         When testing we have a test pass built using old style visibility to improve
+         testing coverage.
+
+         Don't use it explicitly when building with plain .NET (without Proto or Arcade).
+     -->
+    <OtherFlags Condition="'$(Configuration)' != 'Proto' and '$(TestingLegacyInternalSignature)' != 'true'">$(OtherFlags) --realsig-</OtherFlags>
+    <OtherFlags Condition="'$(Configuration)' != 'Proto' and '$(TestingLegacyInternalSignature)' == 'true'">$(OtherFlags) --realsig+</OtherFlags>
+
+  </PropertyGroup>
 
   <Import Project="$(RepoRoot)/Directory.Build.props.user" Condition="Exists('$(RepoRoot)/Directory.Build.props.user')" />
 
diff --git a/FSharp.Compiler.Service.sln.DotSettings b/FSharp.Compiler.Service.sln.DotSettings
index 59e0b85499d..9dc83c0360c 100644
--- a/FSharp.Compiler.Service.sln.DotSettings
+++ b/FSharp.Compiler.Service.sln.DotSettings
@@ -426,7 +426,7 @@
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=mtype/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=mubinds/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=munge/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/UserDictionary/Words/=mustinline/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=shouldinline/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=mutables/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=mval/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=mvid/@EntryIndexedValue">True</s:Boolean>
diff --git a/FSharpBuild.Directory.Build.props b/FSharpBuild.Directory.Build.props
index d0b155bb410..f991ba6b072 100644
--- a/FSharpBuild.Directory.Build.props
+++ b/FSharpBuild.Directory.Build.props
@@ -114,7 +114,7 @@
   <!-- use this to enable good debugging in the Proto bootstrap compiler -->
   <!-- You'll have to remove it to get the actual compiler bo build because optimization is needed for some large methods -->
   <!--
-  <PropertyGroup Condition="'$(Configuration)' == 'Proto'">
+    <PropertyGroup Condition="'$(Configuration)' == 'Proto'">
     <DebugSymbols>true</DebugSymbols>
     <Optimize>false</Optimize>
     <Tailcalls>true</Tailcalls>
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index fe20d6c6c33..a3f9bb53187 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -353,6 +353,62 @@ stages:
                 ArtifactType: Container
                 parallel: true
 
+        - job: WindowsNoRealsig_testCoreclr
+          pool:
+            # The PR build definition sets this variable:
+            #   WindowsMachineQueueName=Windows.vs2022.amd64.open
+            # and there is an alternate build definition that sets this to a queue that is always scouting the
+            # next preview of Visual Studio.
+            name: $(DncEngPublicBuildPool)
+            demands: ImageOverride -equals $(WindowsMachineQueueName)
+          timeoutInMinutes: 120
+          steps:
+          - checkout: self
+            clean: true
+
+          - script: eng\CIBuild.cmd -compressallmetadata -norealsig -testCoreclr -configuration Release
+            env:
+              NativeToolsOnMachine: true
+            displayName: Build
+
+          - task: PublishBuildArtifacts@1
+            displayName: Publish Build BinLog
+            condition: always()
+            continueOnError: true
+            inputs:
+                PathToPublish: '$(Build.SourcesDirectory)\artifacts\log/Release\Build.VisualFSharp.sln.binlog'
+                ArtifactName: 'Windows Release build binlogs'
+                ArtifactType: Container
+                parallel: true
+
+        - job: WindowsNoRealsig_testDesktop
+          pool:
+            # The PR build definition sets this variable:
+            #   WindowsMachineQueueName=Windows.vs2022.amd64.open
+            # and there is an alternate build definition that sets this to a queue that is always scouting the
+            # next preview of Visual Studio.
+            name: $(DncEngPublicBuildPool)
+            demands: ImageOverride -equals $(WindowsMachineQueueName)
+          timeoutInMinutes: 120
+          steps:
+          - checkout: self
+            clean: true
+
+          - script: eng\CIBuild.cmd -compressallmetadata -norealsig -testDesktop -configuration Release
+            env:
+              NativeToolsOnMachine: true
+            displayName: Build
+
+          - task: PublishBuildArtifacts@1
+            displayName: Publish Build BinLog
+            condition: always()
+            continueOnError: true
+            inputs:
+                PathToPublish: '$(Build.SourcesDirectory)\artifacts\log/Release\Build.VisualFSharp.sln.binlog'
+                ArtifactName: 'Windows Release build binlogs'
+                ArtifactType: Container
+                parallel: true
+
         - job: WindowsStrictIndentation
           pool:
             # The PR build definition sets this variable:
@@ -738,7 +794,7 @@ stages:
             condition: always()
 
         # Test trimming on Windows
-        - job: Build_And_Test_Trimming_Windows
+        - job: Build_And_Test_AOT_Windows
           pool:
             name: $(DncEngPublicBuildPool)
             demands: ImageOverride -equals $(WindowsMachineQueueName)
@@ -769,9 +825,9 @@ stages:
             env:
               NativeToolsOnMachine: true
             displayName: Initial build and prepare packages.
-          - script: $(Build.SourcesDirectory)/tests/AheadOfTime/Trimming/check.cmd
+          - script: $(Build.SourcesDirectory)/tests/AheadOfTime/check.cmd
             displayName: Build, trim, publish and check the state of the trimmed app.
-            workingDirectory: $(Build.SourcesDirectory)/tests/AheadOfTime/Trimming
+            workingDirectory: $(Build.SourcesDirectory)/tests/AheadOfTime
           - task: PublishPipelineArtifact@1
             displayName: Publish Trim Tests Logs
             inputs:
diff --git a/docs/optimizations-equality.md b/docs/optimizations-equality.md
new file mode 100644
index 00000000000..acabd8caa2b
--- /dev/null
+++ b/docs/optimizations-equality.md
@@ -0,0 +1,326 @@
+# Compiling Equality
+
+This spec covers how equality is compiled and executed by the F# compiler and library, based mainly on the types involved in the equality operation after all inlining, type specialization and other optimizations have been applied.
+
+## What do we mean by an equality operation?
+
+This spec is about the semantics and performance of the following coding constructs
+
+* `a = b`
+* `a <> b`
+
+It is also about the semantics and performance of uses of the following `FSharp.Core` constructs which, after inlining, generate code that contains an equality check at the specific `EQTYPE`
+* `HashIdentity.Structural<'T>`
+* `{Array,Seq,List}.contains` 
+* `{Array,Seq,List}.countBy` 
+* `{Array,Seq,List}.groupBy`
+* `{Array,Seq,List}.distinct` 
+* `{Array,Seq,List}.distinctBy` 
+* `{Array,Seq,List}.except` 
+
+All of which have implied equality checks. Some of these operations are inlined, see below, which in turn affects the semantics and performance of the overall operation.
+
+## ER vs PER equality
+
+In math, a (binary) relation is a way to describe a relationship between the elements of sets. "Greater than" is a relation for numbers, "Subset of" is a relation for sets.
+
+Here we talk about 3 particular relations:
+1) **Reflexivity** - every element is related to itself
+  - For integers, `=` is reflexive (`a = a` is always true) and `>` is not (`a > a` is never true)
+2) **Symmetry** - if `a` is related to `b`, then `b` is related to `a`
+  - For integers, `=` is symmetric (`a = b` -> `b = a`) and `>` is not (if `a > b` then `b > a` is false)
+3) **Transitivity** -  if `a` is related to `b`, and `b` is related to `c`, then `a` is also related `c`
+  - For integers, `>` is transitive (`a > b` && `b > c` -> `a > c`) and `√` is not (`a = √b` && `b = √c` doesn't mean `a = √c`)
+
+If a relation has 1, 2, and 3, we talk about **Equivalence Relation (ER)**. If a relation only has 2 and 3, we talk about **Partial Equivalence Relation (PER)**.
+
+This matters in comparing floats since they include [NaN](https://en.wikipedia.org/wiki/NaN). Depending on if we consider `NaN = NaN` true or false, we talk about ER or PER comparison respectively. 
+
+## What is the type known to the compiler and library for an equality operation?
+
+The static type known to the F# compiler is crucial to determining the performance of the operation. The runtime type of the equality check is also significant in some situations.
+
+Here we define the relevant static type `EQTYPE` for the different constructs above:
+
+### Basics
+
+* `a = b`:  `EQTYPE` is the statically known type of `a` or `b`
+* `a <> b`: `EQTYPE` is the statically known type of `a` or `b`
+
+### Inlined constructs
+
+* `HashIdentity.Structural<'T>`, `EQTYPE` is the **inlined** `'T` (results in specialized equality)
+* `Array.contains<'T>`, `EQTYPE` is the **inlined** `'T` (results in specialized equality)
+* `List.contains<T>` likewise
+* `Seq.contains<T>` likewise
+
+These only result in naked generic equality if themselves used from a non-inlined generic context.
+
+### Non-inlined constructs always resulting in naked generic equality
+
+* `Array.groupBy<'Key, 'T> f array`, `EQTYPE` is non-inlined `'Key`, results in naked generic equality
+* `Array.countBy array` likewise for `'T`
+* `Array.distinct<'T> array` likewise
+* `Array.distinctBy array` likewise
+* `Array.except array` likewise
+* `List.groupBy` likewise
+* `List.countBy` likewise
+* `List.distinct` likewise
+* `List.distinctBy` likewise
+* `List.except` likewise
+* `Seq.groupBy` likewise
+* `Seq.countBy` likewise
+* `Seq.distinct` likewise
+* `Seq.distinctBy` likewise
+* `Seq.except` likewise
+
+These **always** result in naked generic equality checks.
+
+Example 1:
+
+```fsharp
+let x = HashIdentity.Structural<byte>  // EQTYPE known to compiler is `byte`
+```
+
+Example 2 (a non-inlined "naked" generic context):
+
+```fsharp
+let f2<'T> () =
+   ... some long code
+   // EQTYPE known to the compiler is `'T`
+   // RUNTIME-EQTYPE known to the library is `byte`
+   let x = HashIdentity.Structural<'T>
+   ... some long code
+
+f2<byte>() // performance of this is determined by EQTYPE<'T> and RUNTIME-EQTYPE<byte>
+```
+
+Example 3 (an inlined generic context):
+
+```fsharp
+let f3<'T> () =
+   ... some long code
+   // EQTYPE known to the compiler is `byte`
+   // RUNTIME-EQTYPE known to the library is `byte`
+   let x = HashIdentity.Structural<'T>
+   ... some long code
+
+f3<byte>() // performance of this is determined by EQTYPE<byte> and RUNTIME-EQTYPE<byte>
+```
+
+Example 4 (a generic struct type in a non-inline generic context):
+
+```fsharp
+let f4<'T> () =
+   ... some long code
+   // EQTYPE known to the compiler is `SomeStructType<'T>`
+   // RUNTIME-EQTYPE known to the library is `SomeStructType<byte>`
+   let x = HashIdentity.Structural<SomeStructType<'T>>
+   ... some long code
+
+f4<byte>() // performance of this determined by EQTYPE<SomeStructType<'T>> and RUNTIME-EQTYPE<SomeStructType<byte>>
+```
+
+## How we compile equality "a = b"
+
+This very much depends on the `EQTYPE` involved in the equality as known by the compiler
+
+Aim here is to flesh these all out with:
+* **Semantics**: what semantics the user expects, and what the semantics actually is
+* **Perf expectation**: what perf the user expects
+* **Compilation today**: How we actually compile today
+* **Perf today**: What is the perf we achieve today
+* (Optional) sharplab.io link to how things are in whatever version is selected in sharplab
+* (Optional) notes
+
+### primitive integer types (`int32`, `int64`, ...)
+
+```fsharp
+let f (x: int) (y: int) = (x = y)
+```
+
+* Semantics: equality on primitive
+* Perf: User expects full performance down to native
+* Compilation today: compiles to IL instruction ✅
+* Perf today: good ✅
+* [sharplab int32](https://sharplab.io/#v2:DYLgZgzgNAJiDUAfYBTALgAjBgFADxAwEsA7NASlwE9DSKMBeXPRjK8gWACgg===)
+
+### primitive floating point types (`float32`, `float64`)
+
+```fsharp
+let f (x: float32) (y: float32) = (x = y)
+```
+
+* Semantics: IEEE floating point equality (respecting NaN etc.)
+* Perf: User expects full performance down to native
+* Compilation today: compiles to IL instruction ✅
+* Perf today: good ✅
+* [sharplab float32](https://sharplab.io/#v2:DYLgZgzgNAJiDUAfYBTALgAjBgFADxC2AHsBDNAZgCYBKXAT0LBPOroF5c8NP6aBYAFBA===)
+
+### primitive `string`, `decimal`
+
+* Semantics: .NET equivalent equality, non-localized for strings
+* Perf: User expects full performance down to native
+* Compilation today: compiles to `String.Equals` or `Decimal.op_Equality` call ✅
+* Perf today: good ✅
+* [sharplab decimal](https://sharplab.io/#v2:DYLgZgzgNALiCWwoBMQGoA+wCmMAEYeAFAB4h7LYDG8AtgIbACUxAnuZTQ83gLzEk+eVkwCwAKCA)
+* [sharplab string](https://sharplab.io/#v2:DYLgZgzgNALiCWwoBMQGoA+wCmMAEYeAFAB4h4QwBO8AdgOYCUxAnuZTQ8wLzEl68WjALAAoIA==)
+
+### reference tuple type (size <= 5)
+
+* Semantics: User expects structural
+* Perf: User expects flattening to constituent checks
+* Compilation today: tuple equality is flattened to constituent checks ✅
+* Perf today: good ✅
+* [sharplab (int * double * 'T), with example reductions/optimizations noted](https://sharplab.io/#v2:DYLgZgzgPgsAUMApgFwARlQCgB4iwSwDs0AqVAEwHsBXAIyVTIHIAVASjdQE9UBeLbH25t48TCVFxB/LpIC0cosCJEA5goB8kgOKJCiAE74AxgFEAjtQCGy5D0Gy48BUpWF1crU7gAJKxAALAGFKAFsABysDRAA6XX0jM0sbfDsAMX80B1R5RUJlQjVNHT1DEwtrWy4ASWIjQggTAB4WAEZGVBYAJg6WAGYNVAdcgHlw5HxQ/AAvQ00sckQAN3wDNHiypMrUmrqiRuMRbwyIZAqbCBZqcKQ+1AAZK3drVUQABSMpiaXECDjSxIhCJRQwCVoAGmwXUhfU4mC4EK40K4sNyrkK7mK3iQaGMYUi0QMQkezysrw+k1S+B+fw2gPxIIM8Dp5WSVQA6qlggzCSdcTzQdh2gjUAAyUXMgGs7Z2TnIbnA3mZVB4xWCnpIsUSuAsrYpWVcoEEwx8lUConYO4o3KDSQ4s1qon8EmqF7vT5Umn/BImI2M+DGRDmIbC9rigNBoYanrhnVSvUcw3m2rIeoHB3Gi1WvqSEhHeBAA==)
+
+### reference tuple type (size > 5)
+
+* Semantics: User expects structural
+* Perf: User expects flattening to constituent checks
+* Compilation today: not flattened, compiled to `GenericEqualityIntrinsic`
+* Perf today: the check does type tests, does virtual calls via `IStructuralEqualityComparer`, boxes etc. ❌(Problem1)
+* [sharplab for size 6](https://sharplab.io/#v2:DYLgZgzgPgsAUMApgFwARlQCgB4iwSwDs0AqVI0841MimqyigSidQE9UBeLbL9p+EA==)
+
+### struct tuple type
+
+* Semantics: User expects structural
+* Perf: User expects flattening to constituent checks or at least the same optimizations as tuples
+* Compilation today: compiled to `GenericEqualityIntrinsic`
+* Perf today: boxes, does type tests, does virtual calls via `IStructuralEqualityComparer` etc. ❌(Problem2)
+* [sharplab for size 3](https://sharplab.io/#v2:DYLgZgzgPgsAUMApgFwARlQCgB4lRZAJwFcBjNTASwDs0AqVG+x2gSldQE9UBeLbXl1bwgA=)
+
+### C# or F# enum type
+
+* Semantics: User expects identical to equality on the underlying type
+* Perf: User expects same perf as flattening to underlying type
+* Compilation today: flattens to underlying type
+* Perf today: good ✅
+* [sharplab for C# enum int](https://sharplab.io/#v2:DYLgZgzgNALiCWwA+BYAUMApjABGHAFAB4g4DKAnhDJgLYB0AIgIYUDyYA6ppgNYCUOCjgC8hIqKH90QA===)
+* [sharplab for F# enum int](https://sharplab.io/#v2:DYLgZgzgNALiCWwA+BYAUDAngBwKYAIBRfAXn3X0qXwEFT8BGCq/AIXoCZ11hcZ8w+ABQAPEEQCU+TPVH1ME9EA=)
+
+### C# struct type
+
+* Semantics: User expects call to `IEquatable<T>` if present, but F# spec says call `this.Equals(box that)`, in practice these are the same
+* Perf expected: no boxing
+* Compilation today: `GenericEqualityIntrinsic<SomeStructType>`
+* Perf today: always boxes (Problem3 ❌)
+* [sharplab](https://sharplab.io/#v2:DYLgZgzgNALiCWwA+BYAUMApjABGHAFAB4g4DKAnhDJgLYB0AIgIY0Aq8tmA8mJNgEocFHAF5CRMcIHogA==)
+* Note: [#16615](https://github.com/dotnet/fsharp/pull/16615) will improve things here since we'll start avoiding boxing
+
+### F# struct type (records, tuples - with compiler-generated structural equality)
+
+* Semantics: User expects field-by-field structural equality with no boxing
+* Perf expected: no boxing
+* Compilation today: `GenericEqualityIntrinsic<SomeStructType>`
+* Perf today: always boxes (Problem3 ❌)
+* [sharplab](https://sharplab.io/#v2:DYLgZgzgNALiCWwA+BYAUAbQDwGUYCcBXAYxgD4BddGATwAcBTAAhwHsBbBvI0gCgDcQTeADsYUJoSGiYASiYBedExVNO7AEYN8TAPoA6AGqKm/ZavVadBgKonC6dMAYwmYJrwAeQtp24k5JhoTLxMaWXQgA)
+* Note: the optimization path is a bit strange here, see the reductions below
+
+<details>
+
+<summary>Details</summary>
+
+```fsharp
+(x = y) 
+
+--inline--> 
+
+GenericEquality x y 
+
+--inline--> 
+
+GenericEqualityFast x y 
+
+--inline--> 
+
+GenericEqualityIntrinsic x y
+
+--devirtualize-->
+
+x.Equals(box y, LanguagePrimitives.GenericEqualityComparer);
+```
+
+The struct type has these generated methods:
+```csharp
+    override bool Equals(object y) 
+    override bool Equals(SomeStruct obj)
+    override bool Equals(object obj, IEqualityComparer comp) //with EqualsVal
+```
+
+These call each other in sequence, boxing then unboxing then boxing. We do NOT generate this method, we probably should:
+
+```csharp
+    override bool Equals(SomeStruct obj, IEqualityComparer comp) //with EqualsValUnboxed
+```
+
+If we did, the devirtualizing optimization should reduce to this directly, which would result in no boxing.
+
+</details>
+
+### array type (byte[], int[], some-struct-type[],  ...)
+
+* Semantics: User expects structural
+* Perf expected: User expects perf is sum of constituent parts
+* Compilation today: `GenericEqualityIntrinsic<uint8[]>`
+* Perf today: hand-optimized ([here](https://github.com/dotnet/fsharp/blob/611e4f350e119a4173a2b235eac65539ac2b61b6/src/FSharp.Core/prim-types.fs#L1562)) for some primitive element types ✅ but boxes each element if "other" is struct or generic, see Problem3 ❌, Problem4 ❌ 
+* [sharplab for `byte[]`](https://sharplab.io/#v2:DYLgZgzgPgsAUMApgFwARlQCgB4lQIwE9lEBtAXQEpVDUBeLbemy+IA=)
+* Note: ([#16615](https://github.com/dotnet/fsharp/pull/16615)) will improve this compiling to either ``FSharpEqualityComparer_PER`1<uint8[]>::get_EqualityComparer().Equals(...)`` or ``FSharpEqualityComparer_PER`1<T[]>::get_EqualityComparer().Equals(...)``
+
+### F# large reference record/union type
+
+Here "large" means the compiler-generated structural equality is NOT inlined.
+
+* Semantics: User expects structural by default
+* Perf expected: User expects perf is sum of constituent parts, type-specialized if generic
+* Compilation today: direct call to `Equals(T)`
+* Perf today: the call to `Equals(T)` has specialized code but boxes fields if struct or generic, see Problem3 ❌, Problem4 ❌
+
+### F# tiny reference (anonymous) record or union type
+
+Here "tiny" means the compiler-generated structural equality IS inlined.
+
+* Semantics: User expects structural by default
+* Perf expected: User expects perf is sum of constituent parts, type-specialized if generic
+* Compilation today: flattened, calling `GenericEqualityERIntrinsic` on struct and generic fields
+* Perf today: boxes on struct and generic fields, see Problem3 ❌, Problem4 ❌
+* Note: [#16615](https://github.com/dotnet/fsharp/pull/16615) will help, compiling to ``FSharpEqualityComparer_ER`1<!a>::get_EqualityComparer().Equals(...)`` on struct and generic fields
+
+### Generic `'T` in non-inlined generic code
+
+* Semantics: User expects the PER equality semantics of whatever `'T` actually is  
+* Perf expected: User expects no boxing
+* Compilation today: `GenericEqualityERIntrinsic` 
+* Perf today: boxes if `'T` is any non-reference type (Problem4 ❌)
+* Note:  [#16615](https://github.com/dotnet/fsharp/pull/16615) will improve this compiling to ``FSharpEqualityComparer_ER`1<!a>::get_EqualityComparer().Equals(...)``
+
+### Generic `'T` in recursive position in structural comparison
+
+This case happens in structural equality for tuple types and other structural types
+
+* Semantics: User expects the PER equality semantics of whatever `'T` actually is  
+* Perf: User expects no boxing
+* Compilation today: `GenericEqualityWithComparerIntrinsic LanguagePrimitives.GenericComparer` 
+* Perf today: boxes for if `'T` is any non-reference type (Problem4 ❌)
+* [Sharplab](https://sharplab.io/#v2:DYLgZgzgPgsAUMApgFwARlQCgB4iwSwDs0AqVAEwHsBXAIyVTIHIAVASjdQE9UBeLbH25t48TCVFxB/LpIC0cosCJEA5goB8kgOKJCiAE74AxgFEAjtQCGy5D0Gy48BUpWF1crU7gAJKxAALAGFKAFsABysDRAA6XX0jM0sbfDsAMX80B1R5RUJlQjVNHT1DEwtrWy4ASWIjQggTAB4WAEZGVBYAJg6WAGYNVAdcgHlw5HxQ/AAvQ00sckQAN3wDNHiypMrUmrqiRuMRbwyIZAqbCBZqcKQ+1AAZK3drVUQABSMpiaXECDjSxIhCJRQwCVoAGmwXUhfU4mC4EK40K4sNyrkK7mK3iQaGMYUi0QMQkezysrw+k1S+B+fw2gPxIIM8Dp5WSVQA6qlggzCSdcTzQdh2gjUAAyUXMgGs7Z2TnIbnA3mZVB4xWCnpIsUSuAsrYpWVcoEEwx8lUConYO4o3KDSQ4s1qon8EmqF7vT5Umn/BImI2M+DGRDmIbC9rigNBoYanrhnVSvUcw3m2rIeoHB3Gi1WvqSEhHeBAA==)
+* Note: [#16615](https://github.com/dotnet/fsharp/pull/16615) will compile to ``FSharpEqualityComparer_ER`1<!a>::get_EqualityComparer().Equals(...)`` and avoid boxing in many cases
+
+## Techniques available to us
+ 
+1. Flatten and inline
+2. RCG: Use reflective code generation internally in FSharp.Core
+3. KFS: Rely on known semantics of F# structural types and treat those as special
+4. TS: Hand-code type-specializations using static optimization conditions in FSharp.Core
+5. TT: Type-indexed tables of baked (poss by reflection) equality comparers and functions, where some pre-computation is done 
+6. DV: De-virtualization
+7. DEQ: Use `EqualityComparer<'T>.Default` where possible
+
+## Notes on previous attempts to improve things
+
+### [#5112](https://github.com/dotnet/fsharp/pull/5112)
+
+* Uses TT, DEQ, KFS, DV
+* Focuses on solving Problem4
+* 99% not breaking, apart from the case of value types with custom equality implemented differently than the `EqualityComparer.Default` - the change would lead to the usage of the custom implementation which is reasonable
+
+Note: this included [changes to the optimizer to reduce GenericEqualityIntrinsic](https://github.com/dotnet/fsharp/pull/5112/files#diff-be48dbef2f0baca27a783ac4a31ec0aedb2704c7f42ea3a2b8228513f9904cfbR2360-R2363) down to a type-indexed table lookup fetching an `IEqualityComparer` and calling it. These hand-coded reductions appear unnecessary as the reduction doesn't open up any further optimizations.
\ No newline at end of file
diff --git a/docs/release-notes/.FSharp.Compiler.Service/8.0.300.md b/docs/release-notes/.FSharp.Compiler.Service/8.0.300.md
index 5507157222e..83a1b23aa9f 100644
--- a/docs/release-notes/.FSharp.Compiler.Service/8.0.300.md
+++ b/docs/release-notes/.FSharp.Compiler.Service/8.0.300.md
@@ -1,6 +1,6 @@
 ### Fixed
 
-* Fix wrong range start of INTERP_STRING_END. ([PR #16774](https://github.com/dotnet/fsharp/pull/16774))
+* Fix wrong range start of INTERP_STRING_END. ([PR #16774](https://github.com/dotnet/fsharp/pull/16774), [PR #16785](https://github.com/dotnet/fsharp/pull/16785))
 * Fix missing warning for recursive calls in list comprehensions. ([PR #16652](https://github.com/dotnet/fsharp/pull/16652))
 * Code generated files with > 64K methods and generated symbols crash when loaded. Use infered sequence points for debugging. ([Issue #16399](https://github.com/dotnet/fsharp/issues/16399), [#PR 16514](https://github.com/dotnet/fsharp/pull/16514))
 * `nameof Module` expressions and patterns are processed to link files in `--test:GraphBasedChecking`. ([PR #16550](https://github.com/dotnet/fsharp/pull/16550), [PR #16743](https://github.com/dotnet/fsharp/pull/16743))
@@ -14,6 +14,7 @@
 * Allow calling method with both Optional and ParamArray. ([#PR 16688](https://github.com/dotnet/fsharp/pull/16688), [suggestions #1120](https://github.com/fsharp/fslang-suggestions/issues/1120))
 * Fix release inline optimization, which leads to MethodAccessException if used with `assembly:InternalsVisibleTo`` attribute. ([Issue #16105](https://github.com/dotnet/fsharp/issues/16105), ([PR #16737](https://github.com/dotnet/fsharp/pull/16737))
 * Enforce AttributeTargets on let values and functions. ([PR #16692](https://github.com/dotnet/fsharp/pull/16692))
+* Enforce AttributeTargets on union case declarations. ([PR #16764](https://github.com/dotnet/fsharp/pull/16764))
 
 ### Added
 
@@ -21,6 +22,7 @@
 * Parser recovers on complex primary constructor patterns, better tree representation for primary constructor patterns. ([PR #16425](https://github.com/dotnet/fsharp/pull/16425))
 * Name resolution: keep type vars in subsequent checks ([PR #16456](https://github.com/dotnet/fsharp/pull/16456))
 * Higher-order-function-based API for working with the untyped abstract syntax tree. ([PR #16462](https://github.com/dotnet/fsharp/pull/16462))
+* Add switch to generate types and members with  IL visibility that accurately represents their F# visibility. ([PR #15484](https://github.com/dotnet/fsharp/pull/15484)
 * Allow returning bool instead of unit option for partial active patterns. ([Language suggestion #1041](https://github.com/fsharp/fslang-suggestions/issues/1041), [PR #16473](https://github.com/dotnet/fsharp/pull/16473))
 * Symbols: Add GenericArguments to FSharpEntity ([PR #16470](https://github.com/dotnet/fsharp/pull/16470))
 
diff --git a/docs/release-notes/.FSharp.Core/8.0.300.md b/docs/release-notes/.FSharp.Core/8.0.300.md
index 9acf7d07635..7c3911ae98f 100644
--- a/docs/release-notes/.FSharp.Core/8.0.300.md
+++ b/docs/release-notes/.FSharp.Core/8.0.300.md
@@ -1,3 +1,8 @@
+### Added
+
+* Minor tweaks to inline specifications to support Visibility PR ([PR #15484](https://github.com/dotnet/fsharp/pull/15484), [#PR 16427](https://github.com/dotnet/fsharp/pull/15484)
+* Optimize equality in generic contexts. ([PR #16615](https://github.com/dotnet/fsharp/pull/16615))
+
 ### Fixed
 
-* Preserve original stack traces in resumable state machines generated code if available. ([PR #16568](https://github.com/dotnet/fsharp/pull/16568))
\ No newline at end of file
+* Preserve original stack traces in resumable state machines generated code if available. ([PR #16568](https://github.com/dotnet/fsharp/pull/16568))
diff --git a/docs/release-notes/.Language/preview.md b/docs/release-notes/.Language/preview.md
index f39dd172561..a4dd48f213d 100644
--- a/docs/release-notes/.Language/preview.md
+++ b/docs/release-notes/.Language/preview.md
@@ -9,6 +9,7 @@
 
 * Allow extension methods without type attribute work for types from imported assemblies. ([PR #16368](https://github.com/dotnet/fsharp/pull/16368))
 * Enforce AttributeTargets on let values and functions. ([PR #16692](https://github.com/dotnet/fsharp/pull/16692))
+* Enforce AttributeTargets on union case declarations. ([PR #16764](https://github.com/dotnet/fsharp/pull/16764))
 
 ### Changed
 
diff --git a/docs/release-notes/.VisualStudio/17.10.md b/docs/release-notes/.VisualStudio/17.10.md
index a4b0a8a9f0d..6c27a8fcfd1 100644
--- a/docs/release-notes/.VisualStudio/17.10.md
+++ b/docs/release-notes/.VisualStudio/17.10.md
@@ -1,7 +1,7 @@
 ### Fixed
 
 * Show signature help mid-pipeline in more scenarios. ([PR #16462](https://github.com/dotnet/fsharp/pull/16462))
-* Various unneeded parentheses code fix improvements. ([PR #16578](https://github.com/dotnet/fsharp/pull/16578), [PR #16666](https://github.com/dotnet/fsharp/pull/16666))
+* Various unneeded parentheses code fix improvements. ([PR #16578](https://github.com/dotnet/fsharp/pull/16578), [PR #16666](https://github.com/dotnet/fsharp/pull/16666), [PR #16789](https://github.com/dotnet/fsharp/pull/16789))
 
 ### Changed
 
diff --git a/eng/Build.ps1 b/eng/Build.ps1
index 049ba91217d..bb449e05665 100644
--- a/eng/Build.ps1
+++ b/eng/Build.ps1
@@ -69,6 +69,7 @@ param (
     [switch]$sourceBuild,
     [switch]$skipBuild,
     [switch]$compressAllMetadata,
+    [switch]$norealsig,
     [switch]$verifypackageshipstatus = $false,
     [parameter(ValueFromRemainingArguments = $true)][string[]]$properties)
 
@@ -131,7 +132,8 @@ function Print-Usage() {
     Write-Host "  -sourceBuild                  Simulate building for source-build."
     Write-Host "  -skipbuild                    Skip building product"
     Write-Host "  -compressAllMetadata          Build product with compressed metadata"
-    Write-Host "  -verifypackageshipstatus     Verify whether the packages we are building have already shipped to nuget"
+    Write-Host "  -norealsig                    Build product with realsig- (default use realsig+)"
+    Write-Host "  -verifypackageshipstatus      Verify whether the packages we are building have already shipped to nuget"
     Write-Host ""
     Write-Host "Command line arguments starting with '/p:' are passed through to MSBuild."
 }
@@ -210,6 +212,12 @@ function Process-Arguments() {
         $script:compressAllMetadata = $True;
     }
 
+    if ($norealsig) {
+        $script:realsig = $False;
+    }
+    else {
+        $script:realsig = $True;
+    }        
     if ($verifypackageshipstatus) {
         $script:verifypackageshipstatus = $True;
     }
@@ -288,6 +296,7 @@ function BuildSolution([string] $solutionName, $nopack) {
         /p:TestTargetFrameworks=$testTargetFrameworks `
         /p:DotNetBuildFromSource=$sourceBuild `
         /p:CompressAllMetadata=$CompressAllMetadata `
+        /p:TestingLegacyInternalSignature=$realsig `
         /v:$verbosity `
         $suppressExtensionDeployment `
         @properties
@@ -671,7 +680,7 @@ try {
     }
 
     if ($testAOT) {
-        Push-Location "$RepoRoot\tests\AheadOfTime\Trimming"
+        Push-Location "$RepoRoot\tests\AheadOfTime"
         ./check.cmd
         Pop-Location
     }
diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index 31ab30f9652..e683f21d846 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -30,9 +30,9 @@
     </Dependency>
   </ProductDependencies>
   <ToolsetDependencies>
-    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="8.0.0-beta.24123.1">
+    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="8.0.0-beta.24151.4">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>042763a811fd94dc3556253d4c64118dd665216e</Sha>
+      <Sha>cbb61c3a9a42e7c3cce17ee453ff5ecdc7f69282</Sha>
       <SourceBuild RepoName="arcade" ManagedOnly="true" />
     </Dependency>
     <Dependency Name="Microsoft.DotNet.XliffTasks" Version="1.0.0-beta.23475.1" CoherentParentDependency="Microsoft.DotNet.Arcade.Sdk">
diff --git a/eng/build.sh b/eng/build.sh
index 6e5d09b79d5..f8db4462ff7 100755
--- a/eng/build.sh
+++ b/eng/build.sh
@@ -34,6 +34,7 @@ usage()
   echo "  --skipBuild                    Do not run the build"
   echo "  --prepareMachine               Prepare machine for CI run, clean up processes after build"
   echo "  --sourceBuild                  Simulate building for source-build"
+  echo "  --norealsig                    Build product with realsig- (default use realsig+)"
   echo "  --tfm                          Override the default target framework"
   echo ""
   echo "Command line arguments starting with '/p:' are passed through to MSBuild."
@@ -68,6 +69,7 @@ skip_analyzers=false
 skip_build=false
 prepare_machine=false
 source_build=false
+realsig=true
 properties=""
 
 docker=false
@@ -152,6 +154,9 @@ while [[ $# > 0 ]]; do
     --sourcebuild)
       source_build=true
       ;;
+    --norealsig)
+      realsig=false
+      ;;
     --tfm)
       tfm=$2
       shift
@@ -308,6 +313,7 @@ function BuildSolution {
       /p:QuietRestore=$quiet_restore \
       /p:QuietRestoreBinaryLog="$binary_log" \
       /p:ArcadeBuildFromSource=$source_build \
+      /p:TestingLegacyInternalSignature=$realsig \
       $properties
   fi
 }
diff --git a/eng/common/templates-official/job/job.yml b/eng/common/templates-official/job/job.yml
new file mode 100644
index 00000000000..9e7bebe9af8
--- /dev/null
+++ b/eng/common/templates-official/job/job.yml
@@ -0,0 +1,255 @@
+# Internal resources (telemetry, microbuild) can only be accessed from non-public projects,
+# and some (Microbuild) should only be applied to non-PR cases for internal builds.
+
+parameters:
+# Job schema parameters - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#job
+  cancelTimeoutInMinutes: ''
+  condition: ''
+  container: ''
+  continueOnError: false
+  dependsOn: ''
+  displayName: ''
+  pool: ''
+  steps: []
+  strategy: ''
+  timeoutInMinutes: ''
+  variables: []
+  workspace: ''
+
+# Job base template specific parameters
+  # See schema documentation - https://github.com/dotnet/arcade/blob/master/Documentation/AzureDevOps/TemplateSchema.md
+  artifacts: ''
+  enableMicrobuild: false
+  enablePublishBuildArtifacts: false
+  enablePublishBuildAssets: false
+  enablePublishTestResults: false
+  enablePublishUsingPipelines: false
+  enableBuildRetry: false
+  disableComponentGovernance: ''
+  componentGovernanceIgnoreDirectories: ''
+  mergeTestResults: false
+  testRunTitle: ''
+  testResultsFormat: ''
+  name: ''
+  preSteps: []
+  runAsPublic: false
+# Sbom related params
+  enableSbom: true
+  PackageVersion: 7.0.0
+  BuildDropPath: '$(Build.SourcesDirectory)/artifacts'
+
+jobs:
+- job: ${{ parameters.name }}
+
+  ${{ if ne(parameters.cancelTimeoutInMinutes, '') }}:
+    cancelTimeoutInMinutes: ${{ parameters.cancelTimeoutInMinutes }}
+
+  ${{ if ne(parameters.condition, '') }}:
+    condition: ${{ parameters.condition }}
+
+  ${{ if ne(parameters.container, '') }}:
+    container: ${{ parameters.container }}
+
+  ${{ if ne(parameters.continueOnError, '') }}:
+    continueOnError: ${{ parameters.continueOnError }}
+
+  ${{ if ne(parameters.dependsOn, '') }}:
+    dependsOn: ${{ parameters.dependsOn }}
+
+  ${{ if ne(parameters.displayName, '') }}:
+    displayName: ${{ parameters.displayName }}
+
+  ${{ if ne(parameters.pool, '') }}:
+    pool: ${{ parameters.pool }}
+
+  ${{ if ne(parameters.strategy, '') }}:
+    strategy: ${{ parameters.strategy }}
+
+  ${{ if ne(parameters.timeoutInMinutes, '') }}:
+    timeoutInMinutes: ${{ parameters.timeoutInMinutes }}
+
+  variables:
+  - ${{ if ne(parameters.enableTelemetry, 'false') }}:
+    - name: DOTNET_CLI_TELEMETRY_PROFILE
+      value: '$(Build.Repository.Uri)'
+  - ${{ if eq(parameters.enableRichCodeNavigation, 'true') }}:
+    - name: EnableRichCodeNavigation
+      value: 'true'
+  # Retry signature validation up to three times, waiting 2 seconds between attempts.
+  # See https://learn.microsoft.com/en-us/nuget/reference/errors-and-warnings/nu3028#retry-untrusted-root-failures
+  - name: NUGET_EXPERIMENTAL_CHAIN_BUILD_RETRY_POLICY
+    value: 3,2000
+  - ${{ each variable in parameters.variables }}:
+    # handle name-value variable syntax
+    # example:
+    # - name: [key]
+    #   value: [value]
+    - ${{ if ne(variable.name, '') }}:
+      - name: ${{ variable.name }}
+        value: ${{ variable.value }}
+
+    # handle variable groups
+    - ${{ if ne(variable.group, '') }}:
+      - group: ${{ variable.group }}
+
+    # handle template variable syntax
+    # example:
+    # - template: path/to/template.yml
+    #   parameters:
+    #     [key]: [value]
+    - ${{ if ne(variable.template, '') }}:
+      - template: ${{ variable.template }}
+        ${{ if ne(variable.parameters, '') }}:
+          parameters: ${{ variable.parameters }}
+
+    # handle key-value variable syntax.
+    # example:
+    # - [key]: [value]
+    - ${{ if and(eq(variable.name, ''), eq(variable.group, ''), eq(variable.template, '')) }}:
+      - ${{ each pair in variable }}:
+        - name: ${{ pair.key }}
+          value: ${{ pair.value }}
+
+  # DotNet-HelixApi-Access provides 'HelixApiAccessToken' for internal builds
+  - ${{ if and(eq(parameters.enableTelemetry, 'true'), eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+    - group: DotNet-HelixApi-Access
+
+  ${{ if ne(parameters.workspace, '') }}:
+    workspace: ${{ parameters.workspace }}
+
+  steps:
+  - ${{ if ne(parameters.preSteps, '') }}:
+    - ${{ each preStep in parameters.preSteps }}:
+      - ${{ preStep }}
+
+  - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+    - ${{ if eq(parameters.enableMicrobuild, 'true') }}:
+      - task: MicroBuildSigningPlugin@3
+        displayName: Install MicroBuild plugin
+        inputs:
+          signType: $(_SignType)
+          zipSources: false
+          feedSource: https://dnceng.pkgs.visualstudio.com/_packaging/MicroBuildToolset/nuget/v3/index.json
+        env:
+          TeamName: $(_TeamName)
+        continueOnError: ${{ parameters.continueOnError }}
+        condition: and(succeeded(), in(variables['_SignType'], 'real', 'test'), eq(variables['Agent.Os'], 'Windows_NT'))
+
+  - ${{ if and(eq(parameters.runAsPublic, 'false'), eq(variables['System.TeamProject'], 'internal')) }}:
+    - task: NuGetAuthenticate@1
+
+  - ${{ if and(ne(parameters.artifacts.download, 'false'), ne(parameters.artifacts.download, '')) }}:
+    - task: DownloadPipelineArtifact@2
+      inputs:
+        buildType: current
+        artifactName: ${{ coalesce(parameters.artifacts.download.name, 'Artifacts_$(Agent.OS)_$(_BuildConfig)') }}
+        targetPath: ${{ coalesce(parameters.artifacts.download.path, 'artifacts') }}
+        itemPattern: ${{ coalesce(parameters.artifacts.download.pattern, '**') }}
+
+  - ${{ each step in parameters.steps }}:
+    - ${{ step }}
+
+  - ${{ if eq(parameters.enableRichCodeNavigation, true) }}:
+    - task: RichCodeNavIndexer@0
+      displayName: RichCodeNav Upload
+      inputs:
+        languages: ${{ coalesce(parameters.richCodeNavigationLanguage, 'csharp') }}
+        environment: ${{ coalesce(parameters.richCodeNavigationEnvironment, 'production') }}
+        richNavLogOutputDirectory: $(Build.SourcesDirectory)/artifacts/bin
+        uploadRichNavArtifacts: ${{ coalesce(parameters.richCodeNavigationUploadArtifacts, false) }}
+      continueOnError: true
+
+  - template: /eng/common/templates-official/steps/component-governance.yml
+    parameters:
+      ${{ if eq(parameters.disableComponentGovernance, '') }}:
+        ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest'), eq(parameters.runAsPublic, 'false'), or(startsWith(variables['Build.SourceBranch'], 'refs/heads/release/'), startsWith(variables['Build.SourceBranch'], 'refs/heads/dotnet/'), startsWith(variables['Build.SourceBranch'], 'refs/heads/microsoft/'), eq(variables['Build.SourceBranch'], 'refs/heads/main'))) }}:
+          disableComponentGovernance: false
+        ${{ else }}:
+          disableComponentGovernance: true
+      ${{ else }}:
+        disableComponentGovernance: ${{ parameters.disableComponentGovernance }}
+      componentGovernanceIgnoreDirectories: ${{ parameters.componentGovernanceIgnoreDirectories }}
+
+  - ${{ if eq(parameters.enableMicrobuild, 'true') }}:
+    - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+      - task: MicroBuildCleanup@1
+        displayName: Execute Microbuild cleanup tasks
+        condition: and(always(), in(variables['_SignType'], 'real', 'test'), eq(variables['Agent.Os'], 'Windows_NT'))
+        continueOnError: ${{ parameters.continueOnError }}
+        env:
+          TeamName: $(_TeamName)
+
+  - ${{ if ne(parameters.artifacts.publish, '') }}:
+    - ${{ if and(ne(parameters.artifacts.publish.artifacts, 'false'), ne(parameters.artifacts.publish.artifacts, '')) }}:
+      - task: CopyFiles@2
+        displayName: Gather binaries for publish to artifacts
+        inputs:
+          SourceFolder: 'artifacts/bin'
+          Contents: '**'
+          TargetFolder: '$(Build.ArtifactStagingDirectory)/artifacts/bin'
+      - task: CopyFiles@2
+        displayName: Gather packages for publish to artifacts
+        inputs:
+          SourceFolder: 'artifacts/packages'
+          Contents: '**'
+          TargetFolder: '$(Build.ArtifactStagingDirectory)/artifacts/packages'
+      - task: 1ES.PublishBuildArtifacts@1
+        displayName: Publish pipeline artifacts
+        inputs:
+          PathtoPublish: '$(Build.ArtifactStagingDirectory)/artifacts'
+          PublishLocation: Container
+          ArtifactName: ${{ coalesce(parameters.artifacts.publish.artifacts.name , 'Artifacts_$(Agent.Os)_$(_BuildConfig)') }}
+        continueOnError: true
+        condition: always()
+    - ${{ if and(ne(parameters.artifacts.publish.logs, 'false'), ne(parameters.artifacts.publish.logs, '')) }}:
+      - publish: artifacts/log
+        artifact: ${{ coalesce(parameters.artifacts.publish.logs.name, 'Logs_Build_$(Agent.Os)_$(_BuildConfig)') }}
+        displayName: Publish logs
+        continueOnError: true
+        condition: always()
+
+  - ${{ if ne(parameters.enablePublishBuildArtifacts, 'false') }}:
+    - task: 1ES.PublishBuildArtifacts@1
+      displayName: Publish Logs
+      inputs:
+        PathtoPublish: '$(Build.SourcesDirectory)/artifacts/log/$(_BuildConfig)'
+        PublishLocation: Container
+        ArtifactName: ${{ coalesce(parameters.enablePublishBuildArtifacts.artifactName, '$(Agent.Os)_$(Agent.JobName)' ) }}
+      continueOnError: true
+      condition: always()
+
+  - ${{ if or(and(eq(parameters.enablePublishTestResults, 'true'), eq(parameters.testResultsFormat, '')), eq(parameters.testResultsFormat, 'xunit')) }}:
+    - task: PublishTestResults@2
+      displayName: Publish XUnit Test Results
+      inputs:
+        testResultsFormat: 'xUnit'
+        testResultsFiles: '*.xml'
+        searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_BuildConfig)'
+        testRunTitle: ${{ coalesce(parameters.testRunTitle, parameters.name, '$(System.JobName)') }}-xunit
+        mergeTestResults: ${{ parameters.mergeTestResults }}
+      continueOnError: true
+      condition: always()
+  - ${{ if or(and(eq(parameters.enablePublishTestResults, 'true'), eq(parameters.testResultsFormat, '')), eq(parameters.testResultsFormat, 'vstest')) }}:
+    - task: PublishTestResults@2
+      displayName: Publish TRX Test Results
+      inputs:
+        testResultsFormat: 'VSTest'
+        testResultsFiles: '*.trx'
+        searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_BuildConfig)'
+        testRunTitle: ${{ coalesce(parameters.testRunTitle, parameters.name, '$(System.JobName)') }}-trx
+        mergeTestResults: ${{ parameters.mergeTestResults }}
+      continueOnError: true
+      condition: always()
+
+  - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest'), eq(parameters.enableSbom, 'true')) }}:
+    - template: /eng/common/templates-official/steps/generate-sbom.yml
+      parameters:
+        PackageVersion: ${{ parameters.packageVersion}}
+        BuildDropPath: ${{ parameters.buildDropPath }}
+        IgnoreDirectories: ${{ parameters.componentGovernanceIgnoreDirectories }}
+
+  - ${{ if eq(parameters.enableBuildRetry, 'true') }}:
+    - publish: $(Build.SourcesDirectory)\eng\common\BuildConfiguration
+      artifact: BuildConfiguration
+      displayName: Publish build retry configuration
+      continueOnError: true
diff --git a/eng/common/templates-official/job/onelocbuild.yml b/eng/common/templates-official/job/onelocbuild.yml
new file mode 100644
index 00000000000..ba9ba493032
--- /dev/null
+++ b/eng/common/templates-official/job/onelocbuild.yml
@@ -0,0 +1,112 @@
+parameters:
+  # Optional: dependencies of the job
+  dependsOn: ''
+
+  # Optional: A defined YAML pool - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#pool
+  pool: ''
+    
+  CeapexPat: $(dn-bot-ceapex-package-r) # PAT for the loc AzDO instance https://dev.azure.com/ceapex
+  GithubPat: $(BotAccount-dotnet-bot-repo-PAT)
+
+  SourcesDirectory: $(Build.SourcesDirectory)
+  CreatePr: true
+  AutoCompletePr: false
+  ReusePr: true
+  UseLfLineEndings: true
+  UseCheckedInLocProjectJson: false
+  SkipLocProjectJsonGeneration: false
+  LanguageSet: VS_Main_Languages
+  LclSource: lclFilesInRepo
+  LclPackageId: ''
+  RepoType: gitHub
+  GitHubOrg: dotnet
+  MirrorRepo: ''
+  MirrorBranch: main
+  condition: ''
+  JobNameSuffix: ''
+
+jobs:
+- job: OneLocBuild${{ parameters.JobNameSuffix }}
+  
+  dependsOn: ${{ parameters.dependsOn }}
+
+  displayName: OneLocBuild${{ parameters.JobNameSuffix }}
+
+  variables:
+    - group: OneLocBuildVariables # Contains the CeapexPat and GithubPat
+    - name: _GenerateLocProjectArguments
+      value: -SourcesDirectory ${{ parameters.SourcesDirectory }}
+        -LanguageSet "${{ parameters.LanguageSet }}"
+        -CreateNeutralXlfs
+    - ${{ if eq(parameters.UseCheckedInLocProjectJson, 'true') }}:
+      - name: _GenerateLocProjectArguments
+        value: ${{ variables._GenerateLocProjectArguments }} -UseCheckedInLocProjectJson
+    - template: /eng/common/templates-official/variables/pool-providers.yml
+
+  ${{ if ne(parameters.pool, '') }}:
+    pool: ${{ parameters.pool }}
+  ${{ if eq(parameters.pool, '') }}:
+    pool:
+      # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+      ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+        name: AzurePipelines-EO
+        image: 1ESPT-Windows2022
+        demands: Cmd
+        os: windows
+      # If it's not devdiv, it's dnceng
+      ${{ if ne(variables['System.TeamProject'], 'DevDiv') }}:
+        name: $(DncEngInternalBuildPool)
+        image: 1es-windows-2022-pt
+        os: windows
+
+  steps:
+    - ${{ if ne(parameters.SkipLocProjectJsonGeneration, 'true') }}:
+      - task: Powershell@2
+        inputs:
+          filePath: $(Build.SourcesDirectory)/eng/common/generate-locproject.ps1
+          arguments: $(_GenerateLocProjectArguments)
+        displayName: Generate LocProject.json
+        condition: ${{ parameters.condition }}
+
+    - task: OneLocBuild@2
+      displayName: OneLocBuild
+      env:
+        SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+      inputs:
+        locProj: eng/Localize/LocProject.json
+        outDir: $(Build.ArtifactStagingDirectory)
+        lclSource: ${{ parameters.LclSource }}
+        lclPackageId: ${{ parameters.LclPackageId }}
+        isCreatePrSelected: ${{ parameters.CreatePr }}
+        isAutoCompletePrSelected: ${{ parameters.AutoCompletePr }}
+        ${{ if eq(parameters.CreatePr, true) }}:
+          isUseLfLineEndingsSelected: ${{ parameters.UseLfLineEndings }}
+          ${{ if eq(parameters.RepoType, 'gitHub') }}:
+            isShouldReusePrSelected: ${{ parameters.ReusePr }}
+        packageSourceAuth: patAuth
+        patVariable: ${{ parameters.CeapexPat }}
+        ${{ if eq(parameters.RepoType, 'gitHub') }}:
+          repoType: ${{ parameters.RepoType }}
+          gitHubPatVariable: "${{ parameters.GithubPat }}"
+        ${{ if ne(parameters.MirrorRepo, '') }}:
+          isMirrorRepoSelected: true
+          gitHubOrganization: ${{ parameters.GitHubOrg }}
+          mirrorRepo: ${{ parameters.MirrorRepo }}
+          mirrorBranch: ${{ parameters.MirrorBranch }}
+      condition: ${{ parameters.condition }}
+
+    - task: 1ES.PublishBuildArtifacts@1
+      displayName: Publish Localization Files
+      inputs:
+        PathtoPublish: '$(Build.ArtifactStagingDirectory)/loc'
+        PublishLocation: Container
+        ArtifactName: Loc
+      condition: ${{ parameters.condition }}
+
+    - task: 1ES.PublishBuildArtifacts@1
+      displayName: Publish LocProject.json
+      inputs:
+        PathtoPublish: '$(Build.SourcesDirectory)/eng/Localize/'
+        PublishLocation: Container
+        ArtifactName: Loc
+      condition: ${{ parameters.condition }}
\ No newline at end of file
diff --git a/eng/common/templates-official/job/publish-build-assets.yml b/eng/common/templates-official/job/publish-build-assets.yml
new file mode 100644
index 00000000000..ea5104625fa
--- /dev/null
+++ b/eng/common/templates-official/job/publish-build-assets.yml
@@ -0,0 +1,153 @@
+parameters:
+  configuration: 'Debug'
+
+  # Optional: condition for the job to run
+  condition: ''
+
+  # Optional: 'true' if future jobs should run even if this job fails
+  continueOnError: false
+
+  # Optional: dependencies of the job
+  dependsOn: ''
+
+  # Optional: Include PublishBuildArtifacts task
+  enablePublishBuildArtifacts: false
+
+  # Optional: A defined YAML pool - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#pool
+  pool: {}
+
+  # Optional: should run as a public build even in the internal project
+  #           if 'true', the build won't run any of the internal only steps, even if it is running in non-public projects.
+  runAsPublic: false
+
+  # Optional: whether the build's artifacts will be published using release pipelines or direct feed publishing
+  publishUsingPipelines: false
+
+  # Optional: whether the build's artifacts will be published using release pipelines or direct feed publishing
+  publishAssetsImmediately: false
+
+  artifactsPublishingAdditionalParameters: ''
+
+  signingValidationAdditionalParameters: ''
+
+jobs:
+- job: Asset_Registry_Publish
+
+  dependsOn: ${{ parameters.dependsOn }}
+  timeoutInMinutes: 150
+
+  ${{ if eq(parameters.publishAssetsImmediately, 'true') }}:
+    displayName: Publish Assets
+  ${{ else }}:
+    displayName: Publish to Build Asset Registry
+
+  variables:
+  - template: /eng/common/templates-official/variables/pool-providers.yml
+  - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+    - group: Publish-Build-Assets
+    - group: AzureDevOps-Artifact-Feeds-Pats
+    - name: runCodesignValidationInjection
+      value: false
+    - ${{ if eq(parameters.publishAssetsImmediately, 'true') }}:
+      - template: /eng/common/templates-official/post-build/common-variables.yml
+
+  pool:
+    # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+    ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+      name: AzurePipelines-EO
+      image: 1ESPT-Windows2022
+      demands: Cmd
+      os: windows
+    # If it's not devdiv, it's dnceng
+    ${{ if ne(variables['System.TeamProject'], 'DevDiv') }}:
+      name: $(DncEngInternalBuildPool)
+      image: 1es-windows-2022-pt
+      os: windows
+  steps:
+  - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+    - task: DownloadBuildArtifacts@0
+      displayName: Download artifact
+      inputs:
+        artifactName: AssetManifests
+        downloadPath: '$(Build.StagingDirectory)/Download'
+        checkDownloadedFiles: true
+      condition: ${{ parameters.condition }}
+      continueOnError: ${{ parameters.continueOnError }}
+    
+    - task: NuGetAuthenticate@1
+
+    - task: PowerShell@2
+      displayName: Publish Build Assets
+      inputs:
+        filePath: eng\common\sdk-task.ps1
+        arguments: -task PublishBuildAssets -restore -msbuildEngine dotnet
+          /p:ManifestsPath='$(Build.StagingDirectory)/Download/AssetManifests'
+          /p:BuildAssetRegistryToken=$(MaestroAccessToken)
+          /p:MaestroApiEndpoint=https://maestro-prod.westus2.cloudapp.azure.com
+          /p:PublishUsingPipelines=${{ parameters.publishUsingPipelines }}
+          /p:OfficialBuildId=$(Build.BuildNumber)
+      condition: ${{ parameters.condition }}
+      continueOnError: ${{ parameters.continueOnError }}
+    
+    - task: powershell@2
+      displayName: Create ReleaseConfigs Artifact
+      inputs:
+        targetType: inline
+        script: |
+          Add-Content -Path "$(Build.StagingDirectory)/ReleaseConfigs.txt" -Value $(BARBuildId)
+          Add-Content -Path "$(Build.StagingDirectory)/ReleaseConfigs.txt" -Value "$(DefaultChannels)"
+          Add-Content -Path "$(Build.StagingDirectory)/ReleaseConfigs.txt" -Value $(IsStableBuild)
+    
+    - task: 1ES.PublishBuildArtifacts@1
+      displayName: Publish ReleaseConfigs Artifact
+      inputs:
+        PathtoPublish: '$(Build.StagingDirectory)/ReleaseConfigs.txt'
+        PublishLocation: Container
+        ArtifactName: ReleaseConfigs
+
+    - task: powershell@2
+      displayName: Check if SymbolPublishingExclusionsFile.txt exists
+      inputs:
+        targetType: inline
+        script: |
+          $symbolExclusionfile = "$(Build.SourcesDirectory)/eng/SymbolPublishingExclusionsFile.txt"
+          if(Test-Path -Path $symbolExclusionfile)
+          {
+            Write-Host "SymbolExclusionFile exists"
+            Write-Host "##vso[task.setvariable variable=SymbolExclusionFile]true"
+          }
+          else{
+           Write-Host "Symbols Exclusion file does not exists"
+           Write-Host "##vso[task.setvariable variable=SymbolExclusionFile]false"
+          }
+
+    - task: 1ES.PublishBuildArtifacts@1
+      displayName: Publish SymbolPublishingExclusionsFile Artifact
+      condition: eq(variables['SymbolExclusionFile'], 'true') 
+      inputs:
+        PathtoPublish: '$(Build.SourcesDirectory)/eng/SymbolPublishingExclusionsFile.txt'
+        PublishLocation: Container
+        ArtifactName: ReleaseConfigs
+
+    - ${{ if eq(parameters.publishAssetsImmediately, 'true') }}:
+      - template: /eng/common/templates-official/post-build/setup-maestro-vars.yml
+        parameters:
+          BARBuildId: ${{ parameters.BARBuildId }}
+          PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
+
+      - task: PowerShell@2
+        displayName: Publish Using Darc
+        inputs:
+          filePath: $(Build.SourcesDirectory)/eng/common/post-build/publish-using-darc.ps1
+          arguments: -BuildId $(BARBuildId) 
+            -PublishingInfraVersion 3
+            -AzdoToken '$(publishing-dnceng-devdiv-code-r-build-re)'
+            -MaestroToken '$(MaestroApiAccessToken)'
+            -WaitPublishingFinish true
+            -ArtifactsPublishingAdditionalParameters '${{ parameters.artifactsPublishingAdditionalParameters }}'
+            -SymbolPublishingAdditionalParameters '${{ parameters.symbolPublishingAdditionalParameters }}'
+
+    - ${{ if eq(parameters.enablePublishBuildArtifacts, 'true') }}:
+      - template: /eng/common/templates-official/steps/publish-logs.yml
+        parameters:
+          JobLabel: 'Publish_Artifacts_Logs'     
diff --git a/eng/common/templates-official/job/source-build.yml b/eng/common/templates-official/job/source-build.yml
new file mode 100644
index 00000000000..8aba3b44bb2
--- /dev/null
+++ b/eng/common/templates-official/job/source-build.yml
@@ -0,0 +1,67 @@
+parameters:
+  # This template adds arcade-powered source-build to CI. The template produces a server job with a
+  # default ID 'Source_Build_Complete' to put in a dependency list if necessary.
+
+  # Specifies the prefix for source-build jobs added to pipeline. Use this if disambiguation needed.
+  jobNamePrefix: 'Source_Build'
+
+  # Defines the platform on which to run the job. By default, a linux-x64 machine, suitable for
+  # managed-only repositories. This is an object with these properties:
+  #
+  # name: ''
+  #   The name of the job. This is included in the job ID.
+  # targetRID: ''
+  #   The name of the target RID to use, instead of the one auto-detected by Arcade.
+  # nonPortable: false
+  #   Enables non-portable mode. This means a more specific RID (e.g. fedora.32-x64 rather than
+  #   linux-x64), and compiling against distro-provided packages rather than portable ones.
+  # skipPublishValidation: false
+  #   Disables publishing validation.  By default, a check is performed to ensure no packages are
+  #   published by source-build.
+  # container: ''
+  #   A container to use. Runs in docker.
+  # pool: {}
+  #   A pool to use. Runs directly on an agent.
+  # buildScript: ''
+  #   Specifies the build script to invoke to perform the build in the repo. The default
+  #   './build.sh' should work for typical Arcade repositories, but this is customizable for
+  #   difficult situations.
+  # jobProperties: {}
+  #   A list of job properties to inject at the top level, for potential extensibility beyond
+  #   container and pool.
+  platform: {}
+
+jobs:
+- job: ${{ parameters.jobNamePrefix }}_${{ parameters.platform.name }}
+  displayName: Source-Build (${{ parameters.platform.name }})
+
+  ${{ each property in parameters.platform.jobProperties }}:
+    ${{ property.key }}: ${{ property.value }}
+
+  ${{ if ne(parameters.platform.container, '') }}:
+    container: ${{ parameters.platform.container }}
+
+  ${{ if eq(parameters.platform.pool, '') }}:
+    # The default VM host AzDO pool. This should be capable of running Docker containers: almost all
+    # source-build builds run in Docker, including the default managed platform.
+    # /eng/common/templates-official/variables/pool-providers.yml can't be used here (some customers declare variables already), so duplicate its logic
+    pool:
+      ${{ if eq(variables['System.TeamProject'], 'public') }}:
+        name: $[replace(replace(eq(contains(coalesce(variables['System.PullRequest.TargetBranch'], variables['Build.SourceBranch'], 'refs/heads/main'), 'release'), 'true'), True, 'NetCore-Svc-Public' ), False, 'NetCore-Public')]
+        demands: ImageOverride -equals Build.Ubuntu.1804.Amd64.Open
+
+      ${{ if eq(variables['System.TeamProject'], 'internal') }}:
+        name: $[replace(replace(eq(contains(coalesce(variables['System.PullRequest.TargetBranch'], variables['Build.SourceBranch'], 'refs/heads/main'), 'release'), 'true'), True, 'NetCore1ESPool-Svc-Internal'), False, 'NetCore1ESPool-Internal')]
+        image: 1es-mariner-2-pt
+        os: linux
+
+  ${{ if ne(parameters.platform.pool, '') }}:
+    pool: ${{ parameters.platform.pool }}
+
+  workspace:
+    clean: all
+
+  steps:
+  - template: /eng/common/templates-official/steps/source-build.yml
+    parameters:
+      platform: ${{ parameters.platform }}
diff --git a/eng/common/templates-official/job/source-index-stage1.yml b/eng/common/templates-official/job/source-index-stage1.yml
new file mode 100644
index 00000000000..4b633739170
--- /dev/null
+++ b/eng/common/templates-official/job/source-index-stage1.yml
@@ -0,0 +1,68 @@
+parameters:
+  runAsPublic: false
+  sourceIndexPackageVersion: 1.0.1-20230228.2
+  sourceIndexPackageSource: https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json
+  sourceIndexBuildCommand: powershell -NoLogo -NoProfile -ExecutionPolicy Bypass -Command "eng/common/build.ps1 -restore -build -binarylog -ci"
+  preSteps: []
+  binlogPath: artifacts/log/Debug/Build.binlog
+  condition: ''
+  dependsOn: ''
+  pool: ''
+
+jobs:
+- job: SourceIndexStage1
+  dependsOn: ${{ parameters.dependsOn }}
+  condition: ${{ parameters.condition }}
+  variables:
+  - name: SourceIndexPackageVersion
+    value: ${{ parameters.sourceIndexPackageVersion }}
+  - name: SourceIndexPackageSource
+    value: ${{ parameters.sourceIndexPackageSource }}
+  - name: BinlogPath
+    value: ${{ parameters.binlogPath }}
+  - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+    - group: source-dot-net stage1 variables
+  - template: /eng/common/templates-official/variables/pool-providers.yml
+
+  ${{ if ne(parameters.pool, '') }}:
+    pool: ${{ parameters.pool }}
+  ${{ if eq(parameters.pool, '') }}:
+    pool:
+      ${{ if eq(variables['System.TeamProject'], 'public') }}:
+        name: $(DncEngPublicBuildPool)
+        demands: ImageOverride -equals windows.vs2019.amd64.open
+      ${{ if eq(variables['System.TeamProject'], 'internal') }}:
+        name: $(DncEngInternalBuildPool)
+        image: 1es-windows-2022-pt
+        os: windows
+
+  steps:
+  - ${{ each preStep in parameters.preSteps }}:
+    - ${{ preStep }}
+
+  - task: UseDotNet@2
+    displayName: Use .NET Core SDK 6
+    inputs:
+      packageType: sdk
+      version: 6.0.x
+      installationPath: $(Agent.TempDirectory)/dotnet
+      workingDirectory: $(Agent.TempDirectory)
+
+  - script: |
+      $(Agent.TempDirectory)/dotnet/dotnet tool install BinLogToSln --version $(SourceIndexPackageVersion) --add-source $(SourceIndexPackageSource) --tool-path $(Agent.TempDirectory)/.source-index/tools
+      $(Agent.TempDirectory)/dotnet/dotnet tool install UploadIndexStage1 --version $(SourceIndexPackageVersion) --add-source $(SourceIndexPackageSource) --tool-path $(Agent.TempDirectory)/.source-index/tools
+    displayName: Download Tools
+    # Set working directory to temp directory so 'dotnet' doesn't try to use global.json and use the repo's sdk.
+    workingDirectory: $(Agent.TempDirectory)
+
+  - script: ${{ parameters.sourceIndexBuildCommand }}
+    displayName: Build Repository
+
+  - script: $(Agent.TempDirectory)/.source-index/tools/BinLogToSln -i $(BinlogPath) -r $(Build.SourcesDirectory) -n $(Build.Repository.Name) -o .source-index/stage1output
+    displayName: Process Binlog into indexable sln
+
+  - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+    - script: $(Agent.TempDirectory)/.source-index/tools/UploadIndexStage1 -i .source-index/stage1output -n $(Build.Repository.Name)
+      displayName: Upload stage1 artifacts to source index
+      env:
+        BLOB_CONTAINER_URL: $(source-dot-net-stage1-blob-container-url)
diff --git a/eng/common/templates-official/jobs/codeql-build.yml b/eng/common/templates-official/jobs/codeql-build.yml
new file mode 100644
index 00000000000..b68d3c2f319
--- /dev/null
+++ b/eng/common/templates-official/jobs/codeql-build.yml
@@ -0,0 +1,31 @@
+parameters:
+  # See schema documentation in /Documentation/AzureDevOps/TemplateSchema.md
+  continueOnError: false
+  # Required: A collection of jobs to run - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#job
+  jobs: []
+  # Optional: if specified, restore and use this version of Guardian instead of the default.
+  overrideGuardianVersion: ''
+
+jobs:
+- template: /eng/common/templates-official/jobs/jobs.yml
+  parameters:
+    enableMicrobuild: false
+    enablePublishBuildArtifacts: false
+    enablePublishTestResults: false
+    enablePublishBuildAssets: false
+    enablePublishUsingPipelines: false
+    enableTelemetry: true
+
+    variables:
+      - group: Publish-Build-Assets
+      # The Guardian version specified in 'eng/common/sdl/packages.config'. This value must be kept in
+      # sync with the packages.config file.
+      - name: DefaultGuardianVersion
+        value: 0.109.0
+      - name: GuardianPackagesConfigFile
+        value: $(Build.SourcesDirectory)\eng\common\sdl\packages.config
+      - name: GuardianVersion
+        value: ${{ coalesce(parameters.overrideGuardianVersion, '$(DefaultGuardianVersion)') }}
+  
+    jobs: ${{ parameters.jobs }}
+        
diff --git a/eng/common/templates-official/jobs/jobs.yml b/eng/common/templates-official/jobs/jobs.yml
new file mode 100644
index 00000000000..857a0f8ba43
--- /dev/null
+++ b/eng/common/templates-official/jobs/jobs.yml
@@ -0,0 +1,97 @@
+parameters:
+  # See schema documentation in /Documentation/AzureDevOps/TemplateSchema.md
+  continueOnError: false
+
+  # Optional: Include PublishBuildArtifacts task
+  enablePublishBuildArtifacts: false
+
+  # Optional: Enable publishing using release pipelines
+  enablePublishUsingPipelines: false
+
+  # Optional: Enable running the source-build jobs to build repo from source
+  enableSourceBuild: false
+
+  # Optional: Parameters for source-build template.
+  #           See /eng/common/templates-official/jobs/source-build.yml for options
+  sourceBuildParameters: []
+
+  graphFileGeneration:
+    # Optional: Enable generating the graph files at the end of the build
+    enabled: false
+    # Optional: Include toolset dependencies in the generated graph files
+    includeToolset: false
+    
+  # Required: A collection of jobs to run - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#job
+  jobs: []
+
+  # Optional: Override automatically derived dependsOn value for "publish build assets" job
+  publishBuildAssetsDependsOn: ''
+
+  # Optional: Publish the assets as soon as the publish to BAR stage is complete, rather doing so in a separate stage.
+  publishAssetsImmediately: false
+
+  # Optional: If using publishAssetsImmediately and additional parameters are needed, can be used to send along additional parameters (normally sent to post-build.yml)
+  artifactsPublishingAdditionalParameters: ''
+  signingValidationAdditionalParameters: ''
+
+  # Optional: should run as a public build even in the internal project
+  #           if 'true', the build won't run any of the internal only steps, even if it is running in non-public projects.
+  runAsPublic: false
+
+  enableSourceIndex: false
+  sourceIndexParams: {}
+
+# Internal resources (telemetry, microbuild) can only be accessed from non-public projects,
+# and some (Microbuild) should only be applied to non-PR cases for internal builds.
+
+jobs:
+- ${{ each job in parameters.jobs }}:
+  - template: ../job/job.yml
+    parameters: 
+      # pass along parameters
+      ${{ each parameter in parameters }}:
+        ${{ if ne(parameter.key, 'jobs') }}:
+          ${{ parameter.key }}: ${{ parameter.value }}
+
+      # pass along job properties
+      ${{ each property in job }}:
+        ${{ if ne(property.key, 'job') }}:
+          ${{ property.key }}: ${{ property.value }}
+
+      name: ${{ job.job }}
+
+- ${{ if eq(parameters.enableSourceBuild, true) }}:
+  - template: /eng/common/templates-official/jobs/source-build.yml
+    parameters:
+      allCompletedJobId: Source_Build_Complete
+      ${{ each parameter in parameters.sourceBuildParameters }}:
+        ${{ parameter.key }}: ${{ parameter.value }}
+
+- ${{ if eq(parameters.enableSourceIndex, 'true') }}:
+  - template: ../job/source-index-stage1.yml
+    parameters:
+      runAsPublic: ${{ parameters.runAsPublic }}
+      ${{ each parameter in parameters.sourceIndexParams }}:
+        ${{ parameter.key }}: ${{ parameter.value }}
+
+- ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+  - ${{ if or(eq(parameters.enablePublishBuildAssets, true), eq(parameters.artifacts.publish.manifests, 'true'), ne(parameters.artifacts.publish.manifests, '')) }}:
+    - template: ../job/publish-build-assets.yml
+      parameters:
+        continueOnError: ${{ parameters.continueOnError }}
+        dependsOn:
+        - ${{ if ne(parameters.publishBuildAssetsDependsOn, '') }}:
+          - ${{ each job in parameters.publishBuildAssetsDependsOn }}:
+            - ${{ job.job }}
+        - ${{ if eq(parameters.publishBuildAssetsDependsOn, '') }}:
+          - ${{ each job in parameters.jobs }}:
+            - ${{ job.job }}
+        - ${{ if eq(parameters.enableSourceBuild, true) }}:
+          - Source_Build_Complete
+
+        runAsPublic: ${{ parameters.runAsPublic }}
+        publishUsingPipelines: ${{ parameters.enablePublishUsingPipelines }}
+        publishAssetsImmediately: ${{ parameters.publishAssetsImmediately }}
+        enablePublishBuildArtifacts: ${{ parameters.enablePublishBuildArtifacts }}
+        artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
+        signingValidationAdditionalParameters: ${{ parameters.signingValidationAdditionalParameters }}
diff --git a/eng/common/templates-official/jobs/source-build.yml b/eng/common/templates-official/jobs/source-build.yml
new file mode 100644
index 00000000000..08e5db9bb11
--- /dev/null
+++ b/eng/common/templates-official/jobs/source-build.yml
@@ -0,0 +1,46 @@
+parameters:
+  # This template adds arcade-powered source-build to CI. A job is created for each platform, as
+  # well as an optional server job that completes when all platform jobs complete.
+
+  # The name of the "join" job for all source-build platforms. If set to empty string, the job is
+  # not included. Existing repo pipelines can use this job depend on all source-build jobs
+  # completing without maintaining a separate list of every single job ID: just depend on this one
+  # server job. By default, not included. Recommended name if used: 'Source_Build_Complete'.
+  allCompletedJobId: ''
+
+  # See /eng/common/templates-official/job/source-build.yml
+  jobNamePrefix: 'Source_Build'
+
+  # This is the default platform provided by Arcade, intended for use by a managed-only repo.
+  defaultManagedPlatform:
+    name: 'Managed'
+    container: 'mcr.microsoft.com/dotnet-buildtools/prereqs:centos-stream8'
+
+  # Defines the platforms on which to run build jobs. One job is created for each platform, and the
+  # object in this array is sent to the job template as 'platform'. If no platforms are specified,
+  # one job runs on 'defaultManagedPlatform'.
+  platforms: []
+
+jobs:
+
+- ${{ if ne(parameters.allCompletedJobId, '') }}:
+  - job: ${{ parameters.allCompletedJobId }}
+    displayName: Source-Build Complete
+    pool: server
+    dependsOn:
+    - ${{ each platform in parameters.platforms }}:
+      - ${{ parameters.jobNamePrefix }}_${{ platform.name }}
+    - ${{ if eq(length(parameters.platforms), 0) }}:
+      - ${{ parameters.jobNamePrefix }}_${{ parameters.defaultManagedPlatform.name }}
+
+- ${{ each platform in parameters.platforms }}:
+  - template: /eng/common/templates-official/job/source-build.yml
+    parameters:
+      jobNamePrefix: ${{ parameters.jobNamePrefix }}
+      platform: ${{ platform }}
+
+- ${{ if eq(length(parameters.platforms), 0) }}:
+  - template: /eng/common/templates-official/job/source-build.yml
+    parameters:
+      jobNamePrefix: ${{ parameters.jobNamePrefix }}
+      platform: ${{ parameters.defaultManagedPlatform }}
diff --git a/eng/common/templates-official/post-build/common-variables.yml b/eng/common/templates-official/post-build/common-variables.yml
new file mode 100644
index 00000000000..c24193acfc9
--- /dev/null
+++ b/eng/common/templates-official/post-build/common-variables.yml
@@ -0,0 +1,22 @@
+variables:
+  - group: Publish-Build-Assets
+
+  # Whether the build is internal or not
+  - name: IsInternalBuild
+    value: ${{ and(ne(variables['System.TeamProject'], 'public'), contains(variables['Build.SourceBranch'], 'internal')) }}
+
+  # Default Maestro++ API Endpoint and API Version
+  - name: MaestroApiEndPoint
+    value: "https://maestro-prod.westus2.cloudapp.azure.com"
+  - name: MaestroApiAccessToken
+    value: $(MaestroAccessToken)
+  - name: MaestroApiVersion
+    value: "2020-02-20"
+
+  - name: SourceLinkCLIVersion
+    value: 3.0.0
+  - name: SymbolToolVersion
+    value: 1.0.1
+
+  - name: runCodesignValidationInjection
+    value: false
diff --git a/eng/common/templates-official/post-build/post-build.yml b/eng/common/templates-official/post-build/post-build.yml
new file mode 100644
index 00000000000..5c98fe1c0f3
--- /dev/null
+++ b/eng/common/templates-official/post-build/post-build.yml
@@ -0,0 +1,285 @@
+parameters:
+  # Which publishing infra should be used. THIS SHOULD MATCH THE VERSION ON THE BUILD MANIFEST.
+  # Publishing V1 is no longer supported
+  # Publishing V2 is no longer supported
+  # Publishing V3 is the default
+  - name: publishingInfraVersion
+    displayName: Which version of publishing should be used to promote the build definition?
+    type: number
+    default: 3
+    values:
+    - 3
+
+  - name: BARBuildId
+    displayName: BAR Build Id
+    type: number
+    default: 0
+
+  - name: PromoteToChannelIds
+    displayName: Channel to promote BARBuildId to
+    type: string
+    default: ''
+
+  - name: enableSourceLinkValidation
+    displayName: Enable SourceLink validation
+    type: boolean
+    default: false
+
+  - name: enableSigningValidation
+    displayName: Enable signing validation
+    type: boolean
+    default: true
+
+  - name: enableSymbolValidation
+    displayName: Enable symbol validation
+    type: boolean
+    default: false
+
+  - name: enableNugetValidation
+    displayName: Enable NuGet validation
+    type: boolean
+    default: true
+    
+  - name: publishInstallersAndChecksums
+    displayName: Publish installers and checksums
+    type: boolean
+    default: true
+
+  - name: SDLValidationParameters
+    type: object
+    default:
+      enable: false
+      publishGdn: false
+      continueOnError: false
+      params: ''
+      artifactNames: ''
+      downloadArtifacts: true
+
+  # These parameters let the user customize the call to sdk-task.ps1 for publishing
+  # symbols & general artifacts as well as for signing validation
+  - name: symbolPublishingAdditionalParameters
+    displayName: Symbol publishing additional parameters
+    type: string
+    default: ''
+
+  - name: artifactsPublishingAdditionalParameters
+    displayName: Artifact publishing additional parameters
+    type: string
+    default: ''
+
+  - name: signingValidationAdditionalParameters
+    displayName: Signing validation additional parameters
+    type: string
+    default: ''
+
+  # Which stages should finish execution before post-build stages start
+  - name: validateDependsOn
+    type: object
+    default:
+    - build
+
+  - name: publishDependsOn
+    type: object
+    default:
+    - Validate
+
+  # Optional: Call asset publishing rather than running in a separate stage
+  - name: publishAssetsImmediately
+    type: boolean
+    default: false
+
+stages:
+- ${{ if or(eq( parameters.enableNugetValidation, 'true'), eq(parameters.enableSigningValidation, 'true'), eq(parameters.enableSourceLinkValidation, 'true'), eq(parameters.SDLValidationParameters.enable, 'true')) }}:
+  - stage: Validate
+    dependsOn: ${{ parameters.validateDependsOn }}
+    displayName: Validate Build Assets
+    variables:
+      - template: common-variables.yml
+      - template: /eng/common/templates-official/variables/pool-providers.yml
+    jobs:
+    - job:
+      displayName: NuGet Validation
+      condition: and(succeededOrFailed(), eq( ${{ parameters.enableNugetValidation }}, 'true'))
+      pool:
+        # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+        ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+          name: AzurePipelines-EO
+          image: 1ESPT-Windows2022
+          demands: Cmd
+          os: windows
+        # If it's not devdiv, it's dnceng
+        ${{ else }}:
+          name: $(DncEngInternalBuildPool)
+          image: 1es-windows-2022-pt
+          os: windows
+
+      steps:
+        - template: setup-maestro-vars.yml
+          parameters:
+            BARBuildId: ${{ parameters.BARBuildId }}
+            PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
+
+        - task: DownloadBuildArtifacts@0
+          displayName: Download Package Artifacts
+          inputs:
+            buildType: specific
+            buildVersionToDownload: specific
+            project: $(AzDOProjectName)
+            pipeline: $(AzDOPipelineId)
+            buildId: $(AzDOBuildId)
+            artifactName: PackageArtifacts
+            checkDownloadedFiles: true
+
+        - task: PowerShell@2
+          displayName: Validate
+          inputs:
+            filePath: $(Build.SourcesDirectory)/eng/common/post-build/nuget-validation.ps1
+            arguments: -PackagesPath $(Build.ArtifactStagingDirectory)/PackageArtifacts/ 
+              -ToolDestinationPath $(Agent.BuildDirectory)/Extract/ 
+
+    - job:
+      displayName: Signing Validation
+      condition: and( eq( ${{ parameters.enableSigningValidation }}, 'true'), ne( variables['PostBuildSign'], 'true'))
+      pool:
+        # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+        ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+          name: AzurePipelines-EO
+          image: 1ESPT-Windows2022
+          demands: Cmd
+          os: windows
+        # If it's not devdiv, it's dnceng
+        ${{ else }}:
+          name: $(DncEngInternalBuildPool)
+          image: 1es-windows-2022-pt
+          os: windows
+      steps:
+        - template: setup-maestro-vars.yml
+          parameters:
+            BARBuildId: ${{ parameters.BARBuildId }}
+            PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
+
+        - task: DownloadBuildArtifacts@0
+          displayName: Download Package Artifacts
+          inputs:
+            buildType: specific
+            buildVersionToDownload: specific
+            project: $(AzDOProjectName)
+            pipeline: $(AzDOPipelineId)
+            buildId: $(AzDOBuildId)
+            artifactName: PackageArtifacts
+            checkDownloadedFiles: true
+            itemPattern: |
+              **
+              !**/Microsoft.SourceBuild.Intermediate.*.nupkg
+
+        # This is necessary whenever we want to publish/restore to an AzDO private feed
+        # Since sdk-task.ps1 tries to restore packages we need to do this authentication here
+        # otherwise it'll complain about accessing a private feed.
+        - task: NuGetAuthenticate@1
+          displayName: 'Authenticate to AzDO Feeds'
+
+        # Signing validation will optionally work with the buildmanifest file which is downloaded from
+        # Azure DevOps above.
+        - task: PowerShell@2
+          displayName: Validate
+          inputs:
+            filePath: eng\common\sdk-task.ps1
+            arguments: -task SigningValidation -restore -msbuildEngine vs
+              /p:PackageBasePath='$(Build.ArtifactStagingDirectory)/PackageArtifacts'
+              /p:SignCheckExclusionsFile='$(Build.SourcesDirectory)/eng/SignCheckExclusionsFile.txt'
+              ${{ parameters.signingValidationAdditionalParameters }}
+
+        - template: ../steps/publish-logs.yml
+          parameters:
+            StageLabel: 'Validation'
+            JobLabel: 'Signing'
+            BinlogToolVersion: $(BinlogToolVersion)
+
+    - job:
+      displayName: SourceLink Validation
+      condition: eq( ${{ parameters.enableSourceLinkValidation }}, 'true')
+      pool:
+        # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+        ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+          name: AzurePipelines-EO
+          image: 1ESPT-Windows2022
+          demands: Cmd
+          os: windows
+        # If it's not devdiv, it's dnceng
+        ${{ else }}:
+          name: $(DncEngInternalBuildPool)
+          image: 1es-windows-2022-pt
+          os: windows
+      steps:
+        - template: setup-maestro-vars.yml
+          parameters:
+            BARBuildId: ${{ parameters.BARBuildId }}
+            PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
+
+        - task: DownloadBuildArtifacts@0
+          displayName: Download Blob Artifacts
+          inputs:
+            buildType: specific
+            buildVersionToDownload: specific
+            project: $(AzDOProjectName)
+            pipeline: $(AzDOPipelineId)
+            buildId: $(AzDOBuildId)
+            artifactName: BlobArtifacts
+            checkDownloadedFiles: true
+
+        - task: PowerShell@2
+          displayName: Validate
+          inputs:
+            filePath: $(Build.SourcesDirectory)/eng/common/post-build/sourcelink-validation.ps1
+            arguments: -InputPath $(Build.ArtifactStagingDirectory)/BlobArtifacts/ 
+              -ExtractPath $(Agent.BuildDirectory)/Extract/ 
+              -GHRepoName $(Build.Repository.Name) 
+              -GHCommit $(Build.SourceVersion)
+              -SourcelinkCliVersion $(SourceLinkCLIVersion)
+          continueOnError: true
+
+- ${{ if ne(parameters.publishAssetsImmediately, 'true') }}:
+  - stage: publish_using_darc
+    ${{ if or(eq(parameters.enableNugetValidation, 'true'), eq(parameters.enableSigningValidation, 'true'), eq(parameters.enableSourceLinkValidation, 'true'), eq(parameters.SDLValidationParameters.enable, 'true')) }}:
+      dependsOn: ${{ parameters.publishDependsOn }}
+    ${{ else }}:
+      dependsOn: ${{ parameters.validateDependsOn }}
+    displayName: Publish using Darc
+    variables:
+      - template: common-variables.yml
+      - template: /eng/common/templates-official/variables/pool-providers.yml
+    jobs:
+    - job:
+      displayName: Publish Using Darc
+      timeoutInMinutes: 120
+      pool:
+        # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+        ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+          name: AzurePipelines-EO
+          image: 1ESPT-Windows2022
+          demands: Cmd
+          os: windows
+        # If it's not devdiv, it's dnceng
+        ${{ else }}:
+          name: $(DncEngInternalBuildPool)
+          image: 1es-windows-2022-pt
+          os: windows
+      steps:
+        - template: setup-maestro-vars.yml
+          parameters:
+            BARBuildId: ${{ parameters.BARBuildId }}
+            PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
+
+        - task: NuGetAuthenticate@1
+
+        - task: PowerShell@2
+          displayName: Publish Using Darc
+          inputs:
+            filePath: $(Build.SourcesDirectory)/eng/common/post-build/publish-using-darc.ps1
+            arguments: -BuildId $(BARBuildId) 
+              -PublishingInfraVersion ${{ parameters.publishingInfraVersion }}
+              -AzdoToken '$(publishing-dnceng-devdiv-code-r-build-re)'
+              -MaestroToken '$(MaestroApiAccessToken)'
+              -WaitPublishingFinish true
+              -ArtifactsPublishingAdditionalParameters '${{ parameters.artifactsPublishingAdditionalParameters }}'
+              -SymbolPublishingAdditionalParameters '${{ parameters.symbolPublishingAdditionalParameters }}'
diff --git a/eng/common/templates-official/post-build/setup-maestro-vars.yml b/eng/common/templates-official/post-build/setup-maestro-vars.yml
new file mode 100644
index 00000000000..0c87f149a4a
--- /dev/null
+++ b/eng/common/templates-official/post-build/setup-maestro-vars.yml
@@ -0,0 +1,70 @@
+parameters:
+  BARBuildId: ''
+  PromoteToChannelIds: ''
+
+steps:
+  - ${{ if eq(coalesce(parameters.PromoteToChannelIds, 0), 0) }}:
+    - task: DownloadBuildArtifacts@0
+      displayName: Download Release Configs
+      inputs:
+        buildType: current
+        artifactName: ReleaseConfigs
+        checkDownloadedFiles: true
+
+  - task: PowerShell@2
+    name: setReleaseVars
+    displayName: Set Release Configs Vars
+    inputs:
+      targetType: inline
+      pwsh: true
+      script: |
+        try {
+          if (!$Env:PromoteToMaestroChannels -or $Env:PromoteToMaestroChannels.Trim() -eq '') {
+            $Content = Get-Content $(Build.StagingDirectory)/ReleaseConfigs/ReleaseConfigs.txt
+
+            $BarId = $Content | Select -Index 0
+            $Channels = $Content | Select -Index 1             
+            $IsStableBuild = $Content | Select -Index 2
+
+            $AzureDevOpsProject = $Env:System_TeamProject
+            $AzureDevOpsBuildDefinitionId = $Env:System_DefinitionId
+            $AzureDevOpsBuildId = $Env:Build_BuildId
+          }
+          else {
+            $buildApiEndpoint = "${Env:MaestroApiEndPoint}/api/builds/${Env:BARBuildId}?api-version=${Env:MaestroApiVersion}"
+
+            $apiHeaders = New-Object 'System.Collections.Generic.Dictionary[[String],[String]]'
+            $apiHeaders.Add('Accept', 'application/json')
+            $apiHeaders.Add('Authorization',"Bearer ${Env:MAESTRO_API_TOKEN}")
+
+            $buildInfo = try { Invoke-WebRequest -Method Get -Uri $buildApiEndpoint -Headers $apiHeaders | ConvertFrom-Json } catch { Write-Host "Error: $_" }
+            
+            $BarId = $Env:BARBuildId
+            $Channels = $Env:PromoteToMaestroChannels -split ","
+            $Channels = $Channels -join "]["
+            $Channels = "[$Channels]"
+
+            $IsStableBuild = $buildInfo.stable
+            $AzureDevOpsProject = $buildInfo.azureDevOpsProject
+            $AzureDevOpsBuildDefinitionId = $buildInfo.azureDevOpsBuildDefinitionId
+            $AzureDevOpsBuildId = $buildInfo.azureDevOpsBuildId
+          }
+
+          Write-Host "##vso[task.setvariable variable=BARBuildId]$BarId"
+          Write-Host "##vso[task.setvariable variable=TargetChannels]$Channels"
+          Write-Host "##vso[task.setvariable variable=IsStableBuild]$IsStableBuild"
+
+          Write-Host "##vso[task.setvariable variable=AzDOProjectName]$AzureDevOpsProject"
+          Write-Host "##vso[task.setvariable variable=AzDOPipelineId]$AzureDevOpsBuildDefinitionId"
+          Write-Host "##vso[task.setvariable variable=AzDOBuildId]$AzureDevOpsBuildId"
+        }
+        catch {
+          Write-Host $_
+          Write-Host $_.Exception
+          Write-Host $_.ScriptStackTrace
+          exit 1
+        }
+    env:
+      MAESTRO_API_TOKEN: $(MaestroApiAccessToken)
+      BARBuildId: ${{ parameters.BARBuildId }}
+      PromoteToMaestroChannels: ${{ parameters.PromoteToChannelIds }}
diff --git a/eng/common/templates-official/post-build/trigger-subscription.yml b/eng/common/templates-official/post-build/trigger-subscription.yml
new file mode 100644
index 00000000000..da669030daf
--- /dev/null
+++ b/eng/common/templates-official/post-build/trigger-subscription.yml
@@ -0,0 +1,13 @@
+parameters:
+  ChannelId: 0
+
+steps:
+- task: PowerShell@2
+  displayName: Triggering subscriptions
+  inputs:
+    filePath: $(Build.SourcesDirectory)/eng/common/post-build/trigger-subscriptions.ps1
+    arguments: -SourceRepo $(Build.Repository.Uri)
+      -ChannelId ${{ parameters.ChannelId }}
+      -MaestroApiAccessToken $(MaestroAccessToken)
+      -MaestroApiEndPoint $(MaestroApiEndPoint)
+      -MaestroApiVersion $(MaestroApiVersion)
diff --git a/eng/common/templates-official/steps/add-build-to-channel.yml b/eng/common/templates-official/steps/add-build-to-channel.yml
new file mode 100644
index 00000000000..f67a210d62f
--- /dev/null
+++ b/eng/common/templates-official/steps/add-build-to-channel.yml
@@ -0,0 +1,13 @@
+parameters:
+  ChannelId: 0
+
+steps:
+- task: PowerShell@2
+  displayName: Add Build to Channel
+  inputs:
+    filePath: $(Build.SourcesDirectory)/eng/common/post-build/add-build-to-channel.ps1
+    arguments: -BuildId $(BARBuildId) 
+      -ChannelId ${{ parameters.ChannelId }}
+      -MaestroApiAccessToken $(MaestroApiAccessToken)
+      -MaestroApiEndPoint $(MaestroApiEndPoint)
+      -MaestroApiVersion $(MaestroApiVersion) 
diff --git a/eng/common/templates-official/steps/build-reason.yml b/eng/common/templates-official/steps/build-reason.yml
new file mode 100644
index 00000000000..eba58109b52
--- /dev/null
+++ b/eng/common/templates-official/steps/build-reason.yml
@@ -0,0 +1,12 @@
+# build-reason.yml
+# Description: runs steps if build.reason condition is valid.  conditions is a string of valid build reasons 
+# to include steps (',' separated).
+parameters:
+  conditions: ''
+  steps: []
+
+steps:
+  - ${{ if and( not(startsWith(parameters.conditions, 'not')), contains(parameters.conditions, variables['build.reason'])) }}:
+    - ${{ parameters.steps }}
+  - ${{ if and( startsWith(parameters.conditions, 'not'), not(contains(parameters.conditions, variables['build.reason']))) }}:
+    - ${{ parameters.steps }}
diff --git a/eng/common/templates-official/steps/component-governance.yml b/eng/common/templates-official/steps/component-governance.yml
new file mode 100644
index 00000000000..0ecec47b0c9
--- /dev/null
+++ b/eng/common/templates-official/steps/component-governance.yml
@@ -0,0 +1,13 @@
+parameters:
+  disableComponentGovernance: false
+  componentGovernanceIgnoreDirectories: ''
+
+steps:
+- ${{ if eq(parameters.disableComponentGovernance, 'true') }}:
+  - script: "echo ##vso[task.setvariable variable=skipComponentGovernanceDetection]true"
+    displayName: Set skipComponentGovernanceDetection variable
+- ${{ if ne(parameters.disableComponentGovernance, 'true') }}:
+  - task: ComponentGovernanceComponentDetection@0
+    continueOnError: true
+    inputs:
+      ignoreDirectories: ${{ parameters.componentGovernanceIgnoreDirectories }}
\ No newline at end of file
diff --git a/eng/common/templates-official/steps/execute-codeql.yml b/eng/common/templates-official/steps/execute-codeql.yml
new file mode 100644
index 00000000000..9b4a5ffa30a
--- /dev/null
+++ b/eng/common/templates-official/steps/execute-codeql.yml
@@ -0,0 +1,32 @@
+parameters:
+  # Language that should be analyzed. Defaults to csharp
+  language: csharp
+  # Build Commands
+  buildCommands: ''
+  overrideParameters: ''                                       # Optional: to override values for parameters.
+  additionalParameters: ''                                     # Optional: parameters that need user specific values eg: '-SourceToolsList @("abc","def") -ArtifactToolsList @("ghi","jkl")'
+  # Optional: if specified, restore and use this version of Guardian instead of the default.
+  overrideGuardianVersion: ''
+  # Optional: if true, publish the '.gdn' folder as a pipeline artifact. This can help with in-depth
+  # diagnosis of problems with specific tool configurations.
+  publishGuardianDirectoryToPipeline: false
+  # The script to run to execute all SDL tools. Use this if you want to use a script to define SDL
+  # parameters rather than relying on YAML. It may be better to use a local script, because you can
+  # reproduce results locally without piecing together a command based on the YAML.
+  executeAllSdlToolsScript: 'eng/common/sdl/execute-all-sdl-tools.ps1'
+  # There is some sort of bug (has been reported) in Azure DevOps where if this parameter is named
+  # 'continueOnError', the parameter value is not correctly picked up.
+  # This can also be remedied by the caller (post-build.yml) if it does not use a nested parameter
+  # optional: determines whether to continue the build if the step errors;
+  sdlContinueOnError: false
+
+steps:
+- template: /eng/common/templates-official/steps/execute-sdl.yml
+  parameters:
+    overrideGuardianVersion: ${{ parameters.overrideGuardianVersion }}
+    executeAllSdlToolsScript: ${{ parameters.executeAllSdlToolsScript }}
+    overrideParameters: ${{ parameters.overrideParameters }}
+    additionalParameters: '${{ parameters.additionalParameters }}
+      -CodeQLAdditionalRunConfigParams @("BuildCommands < ${{ parameters.buildCommands }}", "Language < ${{ parameters.language }}")'
+    publishGuardianDirectoryToPipeline: ${{ parameters.publishGuardianDirectoryToPipeline }}
+    sdlContinueOnError: ${{ parameters.sdlContinueOnError }}
\ No newline at end of file
diff --git a/eng/common/templates-official/steps/execute-sdl.yml b/eng/common/templates-official/steps/execute-sdl.yml
new file mode 100644
index 00000000000..07426fde05d
--- /dev/null
+++ b/eng/common/templates-official/steps/execute-sdl.yml
@@ -0,0 +1,88 @@
+parameters:
+  overrideGuardianVersion: ''
+  executeAllSdlToolsScript: ''
+  overrideParameters: ''
+  additionalParameters: ''
+  publishGuardianDirectoryToPipeline: false
+  sdlContinueOnError: false
+  condition: ''
+
+steps:
+- task: NuGetAuthenticate@1
+  inputs:
+    nuGetServiceConnections: GuardianConnect
+
+- task: NuGetToolInstaller@1
+  displayName: 'Install NuGet.exe'
+  
+- ${{ if ne(parameters.overrideGuardianVersion, '') }}:
+  - pwsh: |
+      Set-Location -Path $(Build.SourcesDirectory)\eng\common\sdl
+      . .\sdl.ps1
+      $guardianCliLocation = Install-Gdn -Path $(Build.SourcesDirectory)\.artifacts -Version ${{ parameters.overrideGuardianVersion }}
+      Write-Host "##vso[task.setvariable variable=GuardianCliLocation]$guardianCliLocation"
+    displayName: Install Guardian (Overridden)
+
+- ${{ if eq(parameters.overrideGuardianVersion, '') }}:
+  - pwsh: |
+      Set-Location -Path $(Build.SourcesDirectory)\eng\common\sdl
+      . .\sdl.ps1
+      $guardianCliLocation = Install-Gdn -Path $(Build.SourcesDirectory)\.artifacts
+      Write-Host "##vso[task.setvariable variable=GuardianCliLocation]$guardianCliLocation"
+    displayName: Install Guardian
+
+- ${{ if ne(parameters.overrideParameters, '') }}:
+  - powershell: ${{ parameters.executeAllSdlToolsScript }} ${{ parameters.overrideParameters }}
+    displayName: Execute SDL (Overridden)
+    continueOnError: ${{ parameters.sdlContinueOnError }}
+    condition: ${{ parameters.condition }}
+
+- ${{ if eq(parameters.overrideParameters, '') }}:
+  - powershell: ${{ parameters.executeAllSdlToolsScript }}
+      -GuardianCliLocation $(GuardianCliLocation)
+      -NugetPackageDirectory $(Build.SourcesDirectory)\.packages
+      -AzureDevOpsAccessToken $(dn-bot-dotnet-build-rw-code-rw)
+      ${{ parameters.additionalParameters }}
+    displayName: Execute SDL
+    continueOnError: ${{ parameters.sdlContinueOnError }}
+    condition: ${{ parameters.condition }}
+
+- ${{ if ne(parameters.publishGuardianDirectoryToPipeline, 'false') }}:
+  # We want to publish the Guardian results and configuration for easy diagnosis. However, the
+  # '.gdn' dir is a mix of configuration, results, extracted dependencies, and Guardian default
+  # tooling files. Some of these files are large and aren't useful during an investigation, so
+  # exclude them by simply deleting them before publishing. (As of writing, there is no documented
+  # way to selectively exclude a dir from the pipeline artifact publish task.)
+  - task: DeleteFiles@1
+    displayName: Delete Guardian dependencies to avoid uploading
+    inputs:
+      SourceFolder: $(Agent.BuildDirectory)/.gdn
+      Contents: |
+        c
+        i
+    condition: succeededOrFailed()
+
+  - publish: $(Agent.BuildDirectory)/.gdn
+    artifact: GuardianConfiguration
+    displayName: Publish GuardianConfiguration
+    condition: succeededOrFailed()
+
+  # Publish the SARIF files in a container named CodeAnalysisLogs to enable integration
+  # with the "SARIF SAST Scans Tab" Azure DevOps extension
+  - task: CopyFiles@2
+    displayName: Copy SARIF files
+    inputs:
+      flattenFolders: true
+      sourceFolder:  $(Agent.BuildDirectory)/.gdn/rc/
+      contents: '**/*.sarif'
+      targetFolder: $(Build.SourcesDirectory)/CodeAnalysisLogs
+    condition: succeededOrFailed()
+
+  # Use PublishBuildArtifacts because the SARIF extension only checks this case
+  # see microsoft/sarif-azuredevops-extension#4
+  - task: PublishBuildArtifacts@1
+    displayName: Publish SARIF files to CodeAnalysisLogs container
+    inputs:
+      pathToPublish:  $(Build.SourcesDirectory)/CodeAnalysisLogs
+      artifactName: CodeAnalysisLogs
+    condition: succeededOrFailed()
\ No newline at end of file
diff --git a/eng/common/templates-official/steps/generate-sbom.yml b/eng/common/templates-official/steps/generate-sbom.yml
new file mode 100644
index 00000000000..1bf43bf807a
--- /dev/null
+++ b/eng/common/templates-official/steps/generate-sbom.yml
@@ -0,0 +1,48 @@
+# BuildDropPath - The root folder of the drop directory for which the manifest file will be generated.
+# PackageName - The name of the package this SBOM represents.
+# PackageVersion - The version of the package this SBOM represents. 
+# ManifestDirPath - The path of the directory where the generated manifest files will be placed
+# IgnoreDirectories - Directories to ignore for SBOM generation. This will be passed through to the CG component detector.
+
+parameters:
+  PackageVersion: 8.0.0
+  BuildDropPath: '$(Build.SourcesDirectory)/artifacts'
+  PackageName: '.NET'
+  ManifestDirPath: $(Build.ArtifactStagingDirectory)/sbom
+  IgnoreDirectories: ''
+  sbomContinueOnError: true
+
+steps:
+- task: PowerShell@2 
+  displayName: Prep for SBOM generation in (Non-linux)
+  condition: or(eq(variables['Agent.Os'], 'Windows_NT'), eq(variables['Agent.Os'], 'Darwin'))
+  inputs: 
+    filePath: ./eng/common/generate-sbom-prep.ps1
+    arguments: ${{parameters.manifestDirPath}}
+
+# Chmodding is a workaround for https://github.com/dotnet/arcade/issues/8461
+- script: |
+    chmod +x ./eng/common/generate-sbom-prep.sh
+    ./eng/common/generate-sbom-prep.sh ${{parameters.manifestDirPath}}
+  displayName: Prep for SBOM generation in (Linux)
+  condition: eq(variables['Agent.Os'], 'Linux')
+  continueOnError: ${{ parameters.sbomContinueOnError }}
+
+- task: AzureArtifacts.manifest-generator-task.manifest-generator-task.ManifestGeneratorTask@0
+  displayName: 'Generate SBOM manifest'
+  continueOnError: ${{ parameters.sbomContinueOnError }}
+  inputs:
+      PackageName: ${{ parameters.packageName }}
+      BuildDropPath: ${{ parameters.buildDropPath }}
+      PackageVersion: ${{ parameters.packageVersion }}
+      ManifestDirPath: ${{ parameters.manifestDirPath }}
+      ${{ if ne(parameters.IgnoreDirectories, '') }}:
+        AdditionalComponentDetectorArgs: '--IgnoreDirectories ${{ parameters.IgnoreDirectories }}'
+
+- task: 1ES.PublishPipelineArtifact@1
+  displayName: Publish SBOM manifest
+  continueOnError: ${{parameters.sbomContinueOnError}}
+  inputs:
+    targetPath: '${{parameters.manifestDirPath}}'
+    artifactName: $(ARTIFACT_NAME)
+
diff --git a/eng/common/templates-official/steps/publish-logs.yml b/eng/common/templates-official/steps/publish-logs.yml
new file mode 100644
index 00000000000..04012fed182
--- /dev/null
+++ b/eng/common/templates-official/steps/publish-logs.yml
@@ -0,0 +1,23 @@
+parameters:
+  StageLabel: ''
+  JobLabel: ''
+
+steps:
+- task: Powershell@2
+  displayName: Prepare Binlogs to Upload
+  inputs:
+    targetType: inline
+    script: |
+      New-Item -ItemType Directory $(Build.SourcesDirectory)/PostBuildLogs/${{parameters.StageLabel}}/${{parameters.JobLabel}}/
+      Move-Item -Path $(Build.SourcesDirectory)/artifacts/log/Debug/* $(Build.SourcesDirectory)/PostBuildLogs/${{parameters.StageLabel}}/${{parameters.JobLabel}}/
+  continueOnError: true
+  condition: always()
+
+- task: 1ES.PublishBuildArtifacts@1
+  displayName: Publish Logs
+  inputs:
+    PathtoPublish: '$(Build.SourcesDirectory)/PostBuildLogs'
+    PublishLocation: Container
+    ArtifactName: PostBuildLogs
+  continueOnError: true
+  condition: always()
diff --git a/eng/common/templates-official/steps/retain-build.yml b/eng/common/templates-official/steps/retain-build.yml
new file mode 100644
index 00000000000..83d97a26a01
--- /dev/null
+++ b/eng/common/templates-official/steps/retain-build.yml
@@ -0,0 +1,28 @@
+parameters:
+  # Optional azure devops PAT with build execute permissions for the build's organization,
+  # only needed if the build that should be retained ran on a different organization than 
+  # the pipeline where this template is executing from
+  Token: ''
+  # Optional BuildId to retain, defaults to the current running build
+  BuildId: ''
+  # Azure devops Organization URI for the build in the https://dev.azure.com/<organization> format.
+  # Defaults to the organization the current pipeline is running on
+  AzdoOrgUri: '$(System.CollectionUri)'
+  # Azure devops project for the build. Defaults to the project the current pipeline is running on
+  AzdoProject: '$(System.TeamProject)'
+
+steps:
+  - task: powershell@2
+    inputs:
+      targetType: 'filePath'
+      filePath: eng/common/retain-build.ps1
+      pwsh: true
+      arguments: >
+        -AzdoOrgUri: ${{parameters.AzdoOrgUri}}
+        -AzdoProject ${{parameters.AzdoProject}}
+        -Token ${{coalesce(parameters.Token, '$env:SYSTEM_ACCESSTOKEN') }}
+        -BuildId ${{coalesce(parameters.BuildId, '$env:BUILD_ID')}}
+    displayName: Enable permanent build retention
+    env:
+      SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+      BUILD_ID: $(Build.BuildId)
\ No newline at end of file
diff --git a/eng/common/templates-official/steps/send-to-helix.yml b/eng/common/templates-official/steps/send-to-helix.yml
new file mode 100644
index 00000000000..3eb7e2d5f84
--- /dev/null
+++ b/eng/common/templates-official/steps/send-to-helix.yml
@@ -0,0 +1,91 @@
+# Please remember to update the documentation if you make changes to these parameters!
+parameters:
+  HelixSource: 'pr/default'              # required -- sources must start with pr/, official/, prodcon/, or agent/
+  HelixType: 'tests/default/'            # required -- Helix telemetry which identifies what type of data this is; should include "test" for clarity and must end in '/'
+  HelixBuild: $(Build.BuildNumber)       # required -- the build number Helix will use to identify this -- automatically set to the AzDO build number
+  HelixTargetQueues: ''                  # required -- semicolon-delimited list of Helix queues to test on; see https://helix.dot.net/ for a list of queues
+  HelixAccessToken: ''                   # required -- access token to make Helix API requests; should be provided by the appropriate variable group
+  HelixConfiguration: ''                 # optional -- additional property attached to a job
+  HelixPreCommands: ''                   # optional -- commands to run before Helix work item execution
+  HelixPostCommands: ''                  # optional -- commands to run after Helix work item execution
+  WorkItemDirectory: ''                  # optional -- a payload directory to zip up and send to Helix; requires WorkItemCommand; incompatible with XUnitProjects
+  WorkItemCommand: ''                    # optional -- a command to execute on the payload; requires WorkItemDirectory; incompatible with XUnitProjects
+  WorkItemTimeout: ''                    # optional -- a timeout in TimeSpan.Parse-ready value (e.g. 00:02:00) for the work item command; requires WorkItemDirectory; incompatible with XUnitProjects
+  CorrelationPayloadDirectory: ''        # optional -- a directory to zip up and send to Helix as a correlation payload
+  XUnitProjects: ''                      # optional -- semicolon-delimited list of XUnitProjects to parse and send to Helix; requires XUnitRuntimeTargetFramework, XUnitPublishTargetFramework, XUnitRunnerVersion, and IncludeDotNetCli=true
+  XUnitWorkItemTimeout: ''               # optional -- the workitem timeout in seconds for all workitems created from the xUnit projects specified by XUnitProjects
+  XUnitPublishTargetFramework: ''        # optional -- framework to use to publish your xUnit projects
+  XUnitRuntimeTargetFramework: ''        # optional -- framework to use for the xUnit console runner
+  XUnitRunnerVersion: ''                 # optional -- version of the xUnit nuget package you wish to use on Helix; required for XUnitProjects
+  IncludeDotNetCli: false                # optional -- true will download a version of the .NET CLI onto the Helix machine as a correlation payload; requires DotNetCliPackageType and DotNetCliVersion
+  DotNetCliPackageType: ''               # optional -- either 'sdk', 'runtime' or 'aspnetcore-runtime'; determines whether the sdk or runtime will be sent to Helix; see https://raw.githubusercontent.com/dotnet/core/main/release-notes/releases-index.json
+  DotNetCliVersion: ''                   # optional -- version of the CLI to send to Helix; based on this: https://raw.githubusercontent.com/dotnet/core/main/release-notes/releases-index.json
+  WaitForWorkItemCompletion: true        # optional -- true will make the task wait until work items have been completed and fail the build if work items fail. False is "fire and forget."
+  IsExternal: false                      # [DEPRECATED] -- doesn't do anything, jobs are external if HelixAccessToken is empty and Creator is set
+  HelixBaseUri: 'https://helix.dot.net/' # optional -- sets the Helix API base URI (allows targeting https://helix.int-dot.net )
+  Creator: ''                            # optional -- if the build is external, use this to specify who is sending the job
+  DisplayNamePrefix: 'Run Tests'         # optional -- rename the beginning of the displayName of the steps in AzDO 
+  condition: succeeded()                 # optional -- condition for step to execute; defaults to succeeded()
+  continueOnError: false                 # optional -- determines whether to continue the build if the step errors; defaults to false
+
+steps:
+  - powershell: 'powershell "$env:BUILD_SOURCESDIRECTORY\eng\common\msbuild.ps1 $env:BUILD_SOURCESDIRECTORY\eng\common\helixpublish.proj /restore /p:TreatWarningsAsErrors=false /t:Test /bl:$env:BUILD_SOURCESDIRECTORY\artifacts\log\$env:BuildConfig\SendToHelix.binlog"'
+    displayName: ${{ parameters.DisplayNamePrefix }} (Windows)
+    env:
+      BuildConfig: $(_BuildConfig)
+      HelixSource: ${{ parameters.HelixSource }}
+      HelixType: ${{ parameters.HelixType }}
+      HelixBuild: ${{ parameters.HelixBuild }}
+      HelixConfiguration:  ${{ parameters.HelixConfiguration }}
+      HelixTargetQueues: ${{ parameters.HelixTargetQueues }}
+      HelixAccessToken: ${{ parameters.HelixAccessToken }}
+      HelixPreCommands: ${{ parameters.HelixPreCommands }}
+      HelixPostCommands: ${{ parameters.HelixPostCommands }}
+      WorkItemDirectory: ${{ parameters.WorkItemDirectory }}
+      WorkItemCommand: ${{ parameters.WorkItemCommand }}
+      WorkItemTimeout: ${{ parameters.WorkItemTimeout }}
+      CorrelationPayloadDirectory: ${{ parameters.CorrelationPayloadDirectory }}
+      XUnitProjects: ${{ parameters.XUnitProjects }}
+      XUnitWorkItemTimeout: ${{ parameters.XUnitWorkItemTimeout }}
+      XUnitPublishTargetFramework: ${{ parameters.XUnitPublishTargetFramework }}
+      XUnitRuntimeTargetFramework: ${{ parameters.XUnitRuntimeTargetFramework }}
+      XUnitRunnerVersion: ${{ parameters.XUnitRunnerVersion }}
+      IncludeDotNetCli: ${{ parameters.IncludeDotNetCli }}
+      DotNetCliPackageType: ${{ parameters.DotNetCliPackageType }}
+      DotNetCliVersion: ${{ parameters.DotNetCliVersion }}
+      WaitForWorkItemCompletion: ${{ parameters.WaitForWorkItemCompletion }}
+      HelixBaseUri: ${{ parameters.HelixBaseUri }}
+      Creator: ${{ parameters.Creator }}
+      SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+    condition: and(${{ parameters.condition }}, eq(variables['Agent.Os'], 'Windows_NT'))
+    continueOnError: ${{ parameters.continueOnError }}
+  - script: $BUILD_SOURCESDIRECTORY/eng/common/msbuild.sh $BUILD_SOURCESDIRECTORY/eng/common/helixpublish.proj /restore /p:TreatWarningsAsErrors=false /t:Test /bl:$BUILD_SOURCESDIRECTORY/artifacts/log/$BuildConfig/SendToHelix.binlog
+    displayName: ${{ parameters.DisplayNamePrefix }} (Unix)
+    env:
+      BuildConfig: $(_BuildConfig)
+      HelixSource: ${{ parameters.HelixSource }}
+      HelixType: ${{ parameters.HelixType }}
+      HelixBuild: ${{ parameters.HelixBuild }}
+      HelixConfiguration:  ${{ parameters.HelixConfiguration }}
+      HelixTargetQueues: ${{ parameters.HelixTargetQueues }}
+      HelixAccessToken: ${{ parameters.HelixAccessToken }}
+      HelixPreCommands: ${{ parameters.HelixPreCommands }}
+      HelixPostCommands: ${{ parameters.HelixPostCommands }}
+      WorkItemDirectory: ${{ parameters.WorkItemDirectory }}
+      WorkItemCommand: ${{ parameters.WorkItemCommand }}
+      WorkItemTimeout: ${{ parameters.WorkItemTimeout }}
+      CorrelationPayloadDirectory: ${{ parameters.CorrelationPayloadDirectory }}
+      XUnitProjects: ${{ parameters.XUnitProjects }}
+      XUnitWorkItemTimeout: ${{ parameters.XUnitWorkItemTimeout }}
+      XUnitPublishTargetFramework: ${{ parameters.XUnitPublishTargetFramework }}
+      XUnitRuntimeTargetFramework: ${{ parameters.XUnitRuntimeTargetFramework }}
+      XUnitRunnerVersion: ${{ parameters.XUnitRunnerVersion }}
+      IncludeDotNetCli: ${{ parameters.IncludeDotNetCli }}
+      DotNetCliPackageType: ${{ parameters.DotNetCliPackageType }}
+      DotNetCliVersion: ${{ parameters.DotNetCliVersion }}
+      WaitForWorkItemCompletion: ${{ parameters.WaitForWorkItemCompletion }}
+      HelixBaseUri: ${{ parameters.HelixBaseUri }}
+      Creator: ${{ parameters.Creator }}
+      SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+    condition: and(${{ parameters.condition }}, ne(variables['Agent.Os'], 'Windows_NT'))
+    continueOnError: ${{ parameters.continueOnError }}
diff --git a/eng/common/templates-official/steps/source-build.yml b/eng/common/templates-official/steps/source-build.yml
new file mode 100644
index 00000000000..829f17c34d1
--- /dev/null
+++ b/eng/common/templates-official/steps/source-build.yml
@@ -0,0 +1,129 @@
+parameters:
+  # This template adds arcade-powered source-build to CI.
+
+  # This is a 'steps' template, and is intended for advanced scenarios where the existing build
+  # infra has a careful build methodology that must be followed. For example, a repo
+  # (dotnet/runtime) might choose to clone the GitHub repo only once and store it as a pipeline
+  # artifact for all subsequent jobs to use, to reduce dependence on a strong network connection to
+  # GitHub. Using this steps template leaves room for that infra to be included.
+
+  # Defines the platform on which to run the steps. See 'eng/common/templates-official/job/source-build.yml'
+  # for details. The entire object is described in the 'job' template for simplicity, even though
+  # the usage of the properties on this object is split between the 'job' and 'steps' templates.
+  platform: {}
+
+steps:
+# Build. Keep it self-contained for simple reusability. (No source-build-specific job variables.)
+- script: |
+    set -x
+    df -h
+
+    # If building on the internal project, the artifact feeds variable may be available (usually only if needed)
+    # In that case, call the feed setup script to add internal feeds corresponding to public ones.
+    # In addition, add an msbuild argument to copy the WIP from the repo to the target build location.
+    # This is because SetupNuGetSources.sh will alter the current NuGet.config file, and we need to preserve those
+    # changes.
+    internalRestoreArgs=
+    if [ '$(dn-bot-dnceng-artifact-feeds-rw)' != '$''(dn-bot-dnceng-artifact-feeds-rw)' ]; then
+      # Temporarily work around https://github.com/dotnet/arcade/issues/7709
+      chmod +x $(Build.SourcesDirectory)/eng/common/SetupNugetSources.sh
+      $(Build.SourcesDirectory)/eng/common/SetupNugetSources.sh $(Build.SourcesDirectory)/NuGet.config $(dn-bot-dnceng-artifact-feeds-rw)
+      internalRestoreArgs='/p:CopyWipIntoInnerSourceBuildRepo=true'
+
+      # The 'Copy WIP' feature of source build uses git stash to apply changes from the original repo.
+      # This only works if there is a username/email configured, which won't be the case in most CI runs.
+      git config --get user.email
+      if [ $? -ne 0 ]; then
+        git config user.email dn-bot@microsoft.com
+        git config user.name dn-bot
+      fi
+    fi
+
+    # If building on the internal project, the internal storage variable may be available (usually only if needed)
+    # In that case, add variables to allow the download of internal runtimes if the specified versions are not found
+    # in the default public locations.
+    internalRuntimeDownloadArgs=
+    if [ '$(dotnetbuilds-internal-container-read-token-base64)' != '$''(dotnetbuilds-internal-container-read-token-base64)' ]; then
+      internalRuntimeDownloadArgs='/p:DotNetRuntimeSourceFeed=https://dotnetbuilds.blob.core.windows.net/internal /p:DotNetRuntimeSourceFeedKey=$(dotnetbuilds-internal-container-read-token-base64) --runtimesourcefeed https://dotnetbuilds.blob.core.windows.net/internal --runtimesourcefeedkey $(dotnetbuilds-internal-container-read-token-base64)'
+    fi
+
+    buildConfig=Release
+    # Check if AzDO substitutes in a build config from a variable, and use it if so.
+    if [ '$(_BuildConfig)' != '$''(_BuildConfig)' ]; then
+      buildConfig='$(_BuildConfig)'
+    fi
+
+    officialBuildArgs=
+    if [ '${{ and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}' = 'True' ]; then
+      officialBuildArgs='/p:DotNetPublishUsingPipelines=true /p:OfficialBuildId=$(BUILD.BUILDNUMBER)'
+    fi
+
+    targetRidArgs=
+    if [ '${{ parameters.platform.targetRID }}' != '' ]; then
+      targetRidArgs='/p:TargetRid=${{ parameters.platform.targetRID }}'
+    fi
+
+    runtimeOsArgs=
+    if [ '${{ parameters.platform.runtimeOS }}' != '' ]; then
+      runtimeOsArgs='/p:RuntimeOS=${{ parameters.platform.runtimeOS }}'
+    fi
+
+    baseOsArgs=
+    if [ '${{ parameters.platform.baseOS }}' != '' ]; then
+      baseOsArgs='/p:BaseOS=${{ parameters.platform.baseOS }}'
+    fi
+
+    publishArgs=
+    if [ '${{ parameters.platform.skipPublishValidation }}' != 'true' ]; then
+      publishArgs='--publish'
+    fi
+
+    assetManifestFileName=SourceBuild_RidSpecific.xml
+    if [ '${{ parameters.platform.name }}' != '' ]; then
+      assetManifestFileName=SourceBuild_${{ parameters.platform.name }}.xml
+    fi
+
+    ${{ coalesce(parameters.platform.buildScript, './build.sh') }} --ci \
+      --configuration $buildConfig \
+      --restore --build --pack $publishArgs -bl \
+      $officialBuildArgs \
+      $internalRuntimeDownloadArgs \
+      $internalRestoreArgs \
+      $targetRidArgs \
+      $runtimeOsArgs \
+      $baseOsArgs \
+      /p:SourceBuildNonPortable=${{ parameters.platform.nonPortable }} \
+      /p:ArcadeBuildFromSource=true \
+      /p:AssetManifestFileName=$assetManifestFileName
+  displayName: Build
+
+# Upload build logs for diagnosis.
+- task: CopyFiles@2
+  displayName: Prepare BuildLogs staging directory
+  inputs:
+    SourceFolder: '$(Build.SourcesDirectory)'
+    Contents: |
+      **/*.log
+      **/*.binlog
+      artifacts/source-build/self/prebuilt-report/**
+    TargetFolder: '$(Build.StagingDirectory)/BuildLogs'
+    CleanTargetFolder: true
+  continueOnError: true
+  condition: succeededOrFailed()
+
+- task: 1ES.PublishPipelineArtifact@1
+  displayName: Publish BuildLogs
+  inputs:
+    targetPath: '$(Build.StagingDirectory)/BuildLogs'
+    artifactName: BuildLogs_SourceBuild_${{ parameters.platform.name }}_Attempt$(System.JobAttempt)
+  continueOnError: true
+  condition: succeededOrFailed()
+
+# Manually inject component detection so that we can ignore the source build upstream cache, which contains
+# a nupkg cache of input packages (a local feed).
+# This path must match the upstream cache path in property 'CurrentRepoSourceBuiltNupkgCacheDir'
+# in src\Microsoft.DotNet.Arcade.Sdk\tools\SourceBuild\SourceBuildArcade.targets
+- task: ComponentGovernanceComponentDetection@0
+  displayName: Component Detection (Exclude upstream cache)
+  inputs:
+    ignoreDirectories: '$(Build.SourcesDirectory)/artifacts/source-build/self/src/artifacts/obj/source-built-upstream-cache'
diff --git a/eng/common/templates-official/variables/pool-providers.yml b/eng/common/templates-official/variables/pool-providers.yml
new file mode 100644
index 00000000000..beab7d1bfba
--- /dev/null
+++ b/eng/common/templates-official/variables/pool-providers.yml
@@ -0,0 +1,45 @@
+# Select a pool provider based off branch name. Anything with branch name containing 'release' must go into an -Svc pool, 
+# otherwise it should go into the "normal" pools. This separates out the queueing and billing of released branches.
+
+# Motivation: 
+#   Once a given branch of a repository's output has been officially "shipped" once, it is then considered to be COGS
+#   (Cost of goods sold) and should be moved to a servicing pool provider. This allows both separation of queueing
+#   (allowing release builds and main PR builds to not intefere with each other) and billing (required for COGS.
+#   Additionally, the pool provider name itself may be subject to change when the .NET Core Engineering Services 
+#   team needs to move resources around and create new and potentially differently-named pools. Using this template 
+#   file from an Arcade-ified repo helps guard against both having to update one's release/* branches and renaming.
+
+# How to use: 
+#  This yaml assumes your shipped product branches use the naming convention "release/..." (which many do).
+#  If we find alternate naming conventions in broad usage it can be added to the condition below.
+#
+#  First, import the template in an arcade-ified repo to pick up the variables, e.g.:
+#
+#  variables:
+#  - template: /eng/common/templates-official/variables/pool-providers.yml
+#
+#  ... then anywhere specifying the pool provider use the runtime variables,
+#      $(DncEngInternalBuildPool)
+#
+#        pool:
+#           name: $(DncEngInternalBuildPool)
+#           image: 1es-windows-2022-pt
+
+variables:
+  # Coalesce the target and source branches so we know when a PR targets a release branch
+  # If these variables are somehow missing, fall back to main (tends to have more capacity)
+
+  # Any new -Svc alternative pools should have variables added here to allow for splitting work
+
+  - name: DncEngInternalBuildPool
+    value: $[
+        replace(
+          replace(
+            eq(contains(coalesce(variables['System.PullRequest.TargetBranch'], variables['Build.SourceBranch'], 'refs/heads/main'), 'release'), 'true'),
+            True,
+            'NetCore1ESPool-Svc-Internal'
+          ),
+          False,
+          'NetCore1ESPool-Internal'
+        )
+      ]
\ No newline at end of file
diff --git a/eng/common/templates-official/variables/sdl-variables.yml b/eng/common/templates-official/variables/sdl-variables.yml
new file mode 100644
index 00000000000..dbdd66d4a4b
--- /dev/null
+++ b/eng/common/templates-official/variables/sdl-variables.yml
@@ -0,0 +1,7 @@
+variables:
+# The Guardian version specified in 'eng/common/sdl/packages.config'. This value must be kept in
+# sync with the packages.config file.
+- name: DefaultGuardianVersion
+  value: 0.109.0
+- name: GuardianPackagesConfigFile
+  value: $(Build.SourcesDirectory)\eng\common\sdl\packages.config
\ No newline at end of file
diff --git a/global.json b/global.json
index c784c02c369..599589eadff 100644
--- a/global.json
+++ b/global.json
@@ -17,7 +17,7 @@
     "perl": "5.38.0.1"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Arcade.Sdk": "8.0.0-beta.24123.1",
+    "Microsoft.DotNet.Arcade.Sdk": "8.0.0-beta.24151.4",
     "Microsoft.DotNet.Helix.Sdk": "8.0.0-beta.23255.2"
   }
 }
diff --git a/src/Compiler/Checking/CheckComputationExpressions.fs b/src/Compiler/Checking/CheckComputationExpressions.fs
index f0727c3fc5d..e13e56f2c4b 100644
--- a/src/Compiler/Checking/CheckComputationExpressions.fs
+++ b/src/Compiler/Checking/CheckComputationExpressions.fs
@@ -1838,7 +1838,7 @@ let TcComputationExpression (cenv: cenv) env (overallTy: OverallTy) tpenv (mWhol
                     addVarsToVarSpace varSpace (fun mQueryOp env ->
                         // Normalize the bindings before detecting the bound variables
                         match (List.map (BindingNormalization.NormalizeBinding ValOrMemberBinding cenv env) binds) with
-                        | [ NormalizedBinding(kind = SynBindingKind.Normal; mustInline = false; isMutable = false; pat = pat) ] ->
+                        | [ NormalizedBinding(kind = SynBindingKind.Normal; shouldInline = false; isMutable = false; pat = pat) ] ->
                             // successful case
                             use _holder = TemporarilySuspendReportingTypecheckResultsToSink cenv.tcSink
 
diff --git a/src/Compiler/Checking/CheckDeclarations.fs b/src/Compiler/Checking/CheckDeclarations.fs
index fc2e5e9d19b..c82a5edf6f3 100644
--- a/src/Compiler/Checking/CheckDeclarations.fs
+++ b/src/Compiler/Checking/CheckDeclarations.fs
@@ -305,7 +305,7 @@ let AddRootModuleOrNamespaceRefs g amap m env modrefs =
 
 /// Adjust the TcEnv to make more things 'InternalsVisibleTo'
 let addInternalsAccessibility env (ccu: CcuThunk) =
-    let compPath = CompPath (ccu.ILScopeRef, [])    
+    let compPath = CompPath (ccu.ILScopeRef, TypedTree.SyntaxAccess.Unknown, [])    
     let eInternalsVisibleCompPaths = compPath :: env.eInternalsVisibleCompPaths
     { env with 
         eAccessRights = ComputeAccessRights env.eAccessPath eInternalsVisibleCompPaths env.eFamilyType // update this computed field
@@ -418,8 +418,8 @@ module TcRecdUnionAndEnumDeclarations =
         | ParentNone -> vis 
         | Parent tcref -> combineAccess vis tcref.TypeReprAccessibility
 
-    let MakeRecdFieldSpec _cenv env parent (isStatic, konst, tyR, attrsForProperty, attrsForField, id, nameGenerated, isMutable, vol, xmldoc, vis, m) =
-        let vis, _ = ComputeAccessAndCompPath env None m vis None parent
+    let MakeRecdFieldSpec g env parent (isStatic, konst, tyR, attrsForProperty, attrsForField, id, nameGenerated, isMutable, vol, xmldoc, vis, m) =
+        let vis, _ = ComputeAccessAndCompPath g env None m vis None parent
         let vis = CombineReprAccess parent vis
         Construct.NewRecdField isStatic konst id nameGenerated tyR isMutable vol attrsForProperty attrsForField xmldoc vis false
 
@@ -445,7 +445,7 @@ module TcRecdUnionAndEnumDeclarations =
         let isPrivate = match vis with | Some (SynAccess.Private _) -> true | _ -> false
         if isStatic && (not zeroInit || not isMutable || not isPrivate) then errorR(Error(FSComp.SR.tcStaticValFieldsMustBeMutableAndPrivate(), m))
         let konst = if zeroInit then Some Const.Zero else None
-        let rfspec = MakeRecdFieldSpec cenv env parent (isStatic, konst, tyR, attrsForProperty, attrsForField, id, nameGenerated, isMutable, isVolatile, xmldoc, vis, m)
+        let rfspec = MakeRecdFieldSpec g env parent (isStatic, konst, tyR, attrsForProperty, attrsForField, id, nameGenerated, isMutable, isVolatile, xmldoc, vis, m)
         match parent with
         | Parent tcref when useGenuineField tcref.Deref rfspec ->
             // Recheck the attributes for errors if the definition only generates a field
@@ -511,8 +511,15 @@ module TcRecdUnionAndEnumDeclarations =
                 
     let TcUnionCaseDecl (cenv: cenv) env parent thisTy thisTyInst tpenv hasRQAAttribute (SynUnionCase(Attributes synAttrs, SynIdent(id, _), args, xmldoc, vis, m, _)) =
         let g = cenv.g
-        let attrs = TcAttributes cenv env AttributeTargets.UnionCaseDecl synAttrs // the attributes of a union case decl get attached to the generated "static factory" method
-        let vis, _ = ComputeAccessAndCompPath env None m vis None parent
+        let attrs =
+            // The attributes of a union case decl get attached to the generated "static factory" method
+            // Enforce that the union-cases can only be targeted by attributes with AttributeTargets.Method
+            if g.langVersion.SupportsFeature(LanguageFeature.EnforceAttributeTargetsUnionCaseDeclarations) then
+                TcAttributes cenv env AttributeTargets.Method synAttrs
+            else
+                TcAttributes cenv env AttributeTargets.UnionCaseDecl synAttrs
+            
+        let vis, _ = ComputeAccessAndCompPath g env None m vis None parent
         let vis = CombineReprAccess parent vis
 
         CheckUnionCaseName cenv id hasRQAAttribute
@@ -551,7 +558,7 @@ module TcRecdUnionAndEnumDeclarations =
                 let rfields = 
                     argTys |> List.mapi (fun i (argTy, argInfo) ->
                         let id = (match argInfo.Name with Some id -> id | None -> mkSynId m (mkUnionCaseFieldName nFields i))
-                        MakeRecdFieldSpec cenv env parent (false, None, argTy, [], [], id, argInfo.Name.IsNone, false, false, XmlDoc.Empty, None, m))
+                        MakeRecdFieldSpec g env parent (false, None, argTy, [], [], id, argInfo.Name.IsNone, false, false, XmlDoc.Empty, None, m))
 
                 if not (typeEquiv g recordTy thisTy) then 
                     error(Error(FSComp.SR.tcReturnTypesForUnionMustBeSameAsType(), m))
@@ -573,15 +580,15 @@ module TcRecdUnionAndEnumDeclarations =
             |> List.map (TcUnionCaseDecl cenv env parent thisTy thisTyInst tpenv hasRQAAttribute) 
         unionCasesR |> CheckDuplicates (fun uc -> uc.Id) "union case" 
 
-    let MakeEnumCaseSpec cenv env parent attrs thisTy caseRange (caseIdent: Ident) (xmldoc: PreXmlDoc) value =
-        let vis, _ = ComputeAccessAndCompPath env None caseRange None None parent
+    let MakeEnumCaseSpec g cenv env parent attrs thisTy caseRange (caseIdent: Ident) (xmldoc: PreXmlDoc) value =
+        let vis, _ = ComputeAccessAndCompPath g env None caseRange None None parent
         let vis = CombineReprAccess parent vis
         if caseIdent.idText = "value__" then errorR(Error(FSComp.SR.tcNotValidEnumCaseName(), caseIdent.idRange))
         let checkXmlDocs = cenv.diagnosticOptions.CheckXmlDocs
         let xmlDoc = xmldoc.ToXmlDoc(checkXmlDocs, Some [])
         Construct.NewRecdField true (Some value) caseIdent false thisTy false false [] attrs xmlDoc vis false
 
-    let TcEnumDecl cenv env tpenv parent thisTy fieldTy (SynEnumCase (attributes = Attributes synAttrs; ident = SynIdent (id, _); valueExpr = valueExpr; xmlDoc = xmldoc; range = caseRange)) =
+    let TcEnumDecl g cenv env tpenv parent thisTy fieldTy (SynEnumCase (attributes = Attributes synAttrs; ident = SynIdent (id, _); valueExpr = valueExpr; xmlDoc = xmldoc; range = caseRange)) =
         let attrs = TcAttributes cenv env AttributeTargets.Field synAttrs
         let valueRange = valueExpr.Range
 
@@ -590,19 +597,19 @@ module TcRecdUnionAndEnumDeclarations =
             error(Error(FSComp.SR.tcInvalidEnumerationLiteral(), valueRange))
         | SynExpr.Const (synConst, _) -> 
             let konst = TcConst cenv fieldTy valueRange env synConst
-            MakeEnumCaseSpec cenv env parent attrs thisTy caseRange id xmldoc konst
+            MakeEnumCaseSpec g cenv env parent attrs thisTy caseRange id xmldoc konst
         | _ ->
             let expr, actualTy, _ = TcExprOfUnknownType cenv env tpenv valueExpr
             UnifyTypes cenv env valueRange fieldTy actualTy
             
             match EvalLiteralExprOrAttribArg cenv.g expr with
-            | Expr.Const (konst, _, _) -> MakeEnumCaseSpec cenv env parent attrs thisTy caseRange id xmldoc konst
+            | Expr.Const (konst, _, _) -> MakeEnumCaseSpec g cenv env parent attrs thisTy caseRange id xmldoc konst
             | _ -> error(Error(FSComp.SR.tcInvalidEnumerationLiteral(), valueRange))
 
     let TcEnumDecls (cenv: cenv) env tpenv parent thisTy enumCases =
         let g = cenv.g
         let fieldTy = NewInferenceType g
-        let enumCases' = enumCases |> List.map (TcEnumDecl cenv env tpenv parent thisTy fieldTy) |> CheckDuplicates (fun f -> f.Id) "enum element"
+        let enumCases' = enumCases |> List.map (TcEnumDecl g cenv env tpenv parent thisTy fieldTy) |> CheckDuplicates (fun f -> f.Id) "enum element"
         fieldTy, enumCases'
 
 //-------------------------------------------------------------------------
@@ -663,7 +670,7 @@ let TcOpenModuleOrNamespaceDecl tcSink g amap scopem env (longId, m) =
             CheckNamespaceModuleOrTypeName g id
 
     let IsPartiallyQualifiedNamespace (modref: ModuleOrNamespaceRef) = 
-        let (CompPath(_, p)) = modref.CompilationPath 
+        let (CompPath(_, _, p)) = modref.CompilationPath 
         // Bug FSharp 1.0 3274: FSI paths don't count when determining this warning
         let p = 
             match p with 
@@ -2389,10 +2396,10 @@ let CheckForDuplicateModule env nm m =
 /// Check 'exception' declarations in implementations and signatures
 module TcExceptionDeclarations = 
 
-    let TcExnDefnCore_Phase1A cenv env parent (SynExceptionDefnRepr(Attributes synAttrs, SynUnionCase(ident= SynIdent(id,_)), _, xmlDoc, vis, m)) =
+    let TcExnDefnCore_Phase1A g cenv env parent (SynExceptionDefnRepr(Attributes synAttrs, SynUnionCase(ident= SynIdent(id,_)), _, xmlDoc, vis, m)) =
         let attrs = TcAttributes cenv env AttributeTargets.ExnDecl synAttrs
         if not (String.isLeadingIdentifierCharacterUpperCase id.idText) then errorR(NotUpperCaseConstructor id.idRange)
-        let vis, cpath = ComputeAccessAndCompPath env None m vis None parent
+        let vis, cpath = ComputeAccessAndCompPath g env None m vis None parent
         let vis = TcRecdUnionAndEnumDeclarations.CombineReprAccess parent vis
         CheckForDuplicateConcreteType env (id.idText + "Exception") id.idRange
         CheckForDuplicateConcreteType env id.idText id.idRange
@@ -2463,7 +2470,7 @@ module TcExceptionDeclarations =
 
     let private TcExnDefnCore (cenv: cenv) env parent synExnDefnRepr =
         let g = cenv.g
-        let exnc = TcExnDefnCore_Phase1A cenv env parent synExnDefnRepr
+        let exnc = TcExnDefnCore_Phase1A g cenv env parent synExnDefnRepr
         let args' = TcExnDefnCore_Phase1G_EstablishRepresentation cenv env parent exnc synExnDefnRepr
         exnc.TypeContents.tcaug_super <- Some g.exn_ty
 
@@ -2730,7 +2737,7 @@ module EstablishTypeDefinitionCores =
         let moduleKind = ComputeModuleOrNamespaceKind g true typeNames modAttrs id.idText
         let modName = AdjustModuleName moduleKind id.idText
 
-        let vis, _ = ComputeAccessAndCompPath envInitial None id.idRange vis None parent
+        let vis, _ = ComputeAccessAndCompPath g envInitial None id.idRange vis None parent
              
         CheckForDuplicateModule envInitial id.idText id.idRange
         let id = ident (modName, id.idRange)
@@ -2759,13 +2766,13 @@ module EstablishTypeDefinitionCores =
 
         match synTyconRepr with 
         | SynTypeDefnSimpleRepr.Exception synExnDefnRepr -> 
-          TcExceptionDeclarations.TcExnDefnCore_Phase1A cenv env parent synExnDefnRepr
+          TcExceptionDeclarations.TcExnDefnCore_Phase1A g cenv env parent synExnDefnRepr
         | _ ->
         let id = ComputeTyconName (id, (match synTyconRepr with SynTypeDefnSimpleRepr.TypeAbbrev _ -> false | _ -> true), checkedTypars)
 
         // Augmentations of type definitions are allowed within the same file as long as no new type representation or abbreviation is given 
         CheckForDuplicateConcreteType env id.idText id.idRange
-        let vis, cpath = ComputeAccessAndCompPath env None id.idRange synVis None parent
+        let vis, cpath = ComputeAccessAndCompPath g env None id.idRange synVis None parent
 
         // Establish the visibility of the representation, e.g.
         //   type R = 
@@ -2782,7 +2789,8 @@ module EstablishTypeDefinitionCores =
             | SynTypeDefnSimpleRepr.Enum _ -> None
             | SynTypeDefnSimpleRepr.Exception _ -> None
          
-        let visOfRepr, _ = ComputeAccessAndCompPath env None id.idRange synVisOfRepr None parent
+        let visOfRepr, _ = ComputeAccessAndCompPath g env None id.idRange synVisOfRepr None parent
+
         let visOfRepr = combineAccess vis visOfRepr 
         // If we supported nested types and modules then additions would be needed here
         let lmodTy = MaybeLazy.Strict (Construct.NewEmptyModuleOrNamespaceType ModuleOrType)
@@ -4818,7 +4826,7 @@ let rec TcSignatureElementNonMutRec (cenv: cenv) parent typeNames endm (env: TcE
                 return! TcSignatureElementsMutRec cenv parent typeNames endm None env [modDecl]
             else
                 let id = ComputeModuleName longPath
-                let vis, _ = ComputeAccessAndCompPath env None im vis None parent
+                let vis, _ = ComputeAccessAndCompPath g env None im vis None parent
                 let attribs = TcAttributes cenv env AttributeTargets.ModuleDecl attribs
                 CheckNamespaceModuleOrTypeName g id
                 let moduleKind = EstablishTypeDefinitionCores.ComputeModuleOrNamespaceKind g true typeNames attribs id.idText
@@ -5159,7 +5167,7 @@ let rec TcModuleOrNamespaceElementNonMutRec (cenv: cenv) parent typeNames scopem
               let modName = EstablishTypeDefinitionCores.AdjustModuleName moduleKind id.idText
               CheckForDuplicateConcreteType env modName im
               CheckForDuplicateModule env id.idText id.idRange
-              let vis, _ = ComputeAccessAndCompPath env None id.idRange vis None parent
+              let vis, _ = ComputeAccessAndCompPath g env None id.idRange vis None parent
              
               let endm = m.EndRange
               let id = ident (modName, id.idRange)
@@ -5673,7 +5681,10 @@ let CheckOneImplFile
                 |]
         let cenv =
             cenv.Create (g, isScript, amap, thisCcu, false, Option.isSome rootSigOpt,
-                conditionalDefines, tcSink, (LightweightTcValForUsingInBuildMethodCall g), isInternalTestSpanStackReferring,
+                conditionalDefines,
+                tcSink,
+                LightweightTcValForUsingInBuildMethodCall g,
+                isInternalTestSpanStackReferring,
                 diagnosticOptions,
                 tcPat=TcPat,
                 tcSimplePats=TcSimplePats,
@@ -5766,7 +5777,7 @@ let CheckOneImplFile
                                 Activity.Tags.qualifiedNameOfFile, qualNameOfFile.Text
                             |]
                     PostTypeCheckSemanticChecks.CheckImplFile 
-                       (g, cenv.amap, reportErrors, cenv.infoReader, 
+                       (g, cenv.amap,  reportErrors, cenv.infoReader, 
                         env.eInternalsVisibleCompPaths, cenv.thisCcu, tcVal, envAtEnd.DisplayEnv, 
                         implFileTy, implFileContents, extraAttribs, isLastCompiland, 
                         isInternalTestSpanStackReferring)
@@ -5812,15 +5823,17 @@ let CheckOneSigFile (g, amap, thisCcu, checkForErrors, conditionalDefines, tcSin
                 Activity.Tags.qualifiedNameOfFile, sigFile.QualifiedName.Text
             |]
     let cenv =
-        cenv.Create 
-            (g, false, amap, thisCcu, true, false, conditionalDefines, tcSink,
-             (LightweightTcValForUsingInBuildMethodCall g), isInternalTestSpanStackReferring,
-             diagnosticOptions,
-             tcPat=TcPat,
-             tcSimplePats=TcSimplePats,
-             tcSequenceExpressionEntry=TcSequenceExpressionEntry,
-             tcArrayOrListSequenceExpression=TcArrayOrListComputedExpression,
-             tcComputationExpression=TcComputationExpression)
+        cenv.Create(g, false, amap, thisCcu, true, false,
+            conditionalDefines,
+            tcSink,
+            LightweightTcValForUsingInBuildMethodCall g,
+            isInternalTestSpanStackReferring,
+            diagnosticOptions,
+            tcPat=TcPat,
+            tcSimplePats=TcSimplePats,
+            tcSequenceExpressionEntry=TcSequenceExpressionEntry,
+            tcArrayOrListSequenceExpression=TcArrayOrListComputedExpression,
+            tcComputationExpression=TcComputationExpression)
 
     let envinner, moduleTyAcc = MakeInitialEnv tcEnv 
 
diff --git a/src/Compiler/Checking/CheckExpressions.fs b/src/Compiler/Checking/CheckExpressions.fs
index 3e3e90a72fe..f7e048223bf 100644
--- a/src/Compiler/Checking/CheckExpressions.fs
+++ b/src/Compiler/Checking/CheckExpressions.fs
@@ -1177,7 +1177,7 @@ let CombineVisibilityAttribs vis1 vis2 m =
         vis1
     | _ -> vis2
 
-let ComputeAccessAndCompPath env (declKindOpt: DeclKind option) m vis overrideVis actualParent =
+let ComputeAccessAndCompPath (g:TcGlobals) env (declKindOpt: DeclKind option) m vis overrideVis actualParent =
     let accessPath = env.eAccessPath
     let accessModPermitted =
         match declKindOpt with
@@ -1188,12 +1188,13 @@ let ComputeAccessAndCompPath env (declKindOpt: DeclKind option) m vis overrideVi
         errorR(Error(FSComp.SR.tcMultipleVisibilityAttributesWithLet(), m))
 
     let vis =
-        match overrideVis, vis with
-        | Some v, _ -> v
-        | _, None -> taccessPublic (* a module or member binding defaults to "public" *)
-        | _, Some (SynAccess.Public _) -> taccessPublic
-        | _, Some (SynAccess.Private _) -> taccessPrivate accessPath
-        | _, Some (SynAccess.Internal _) -> taccessInternal
+        match declKindOpt, overrideVis, vis with
+        | _, Some v, _ -> v
+        | Some (DeclKind.ClassLetBinding _), _, None when g.realsig -> taccessPrivate accessPath  // a type binding defaults to "private"
+        | _, _, None ->  taccessPublic                                                  // a module or member binding defaults to "public"
+        | _, _, Some (SynAccess.Public _) -> taccessPublic
+        | _, _, Some (SynAccess.Private _) -> taccessPrivate accessPath
+        | _, _, Some (SynAccess.Internal _) -> taccessInternal
 
     let vis =
         match actualParent with
@@ -1319,7 +1320,7 @@ let MakeAndPublishVal (cenv: cenv) env (altActualParent, inSig, declKind, valRec
             Parent(memberInfo.ApparentEnclosingEntity), vis
         | _ -> altActualParent, None
 
-    let vis, _ = ComputeAccessAndCompPath env (Some declKind) id.idRange vis overrideVis actualParent
+    let vis, _ = ComputeAccessAndCompPath g env (Some declKind) id.idRange vis overrideVis actualParent
 
     let inlineFlag = 
         if HasFSharpAttributeOpt g g.attrib_DllImportAttribute attrs then 
@@ -2365,7 +2366,7 @@ type NormalizedBinding =
   | NormalizedBinding of
       visibility: SynAccess option *
       kind: SynBindingKind *
-      mustInline: bool *
+      shouldInline: bool *
       isMutable: bool *
       attribs: SynAttribute list *
       xmlDoc: XmlDoc *
@@ -10874,17 +10875,31 @@ and TcNormalizedBinding declKind (cenv: cenv) env tpenv overallTy safeThisValOpt
                 errorR(Error(FSComp.SR.tcLiteralCannotHaveGenericParameters(), mBinding))
             
         if g.langVersion.SupportsFeature(LanguageFeature.EnforceAttributeTargetsOnFunctions) && memberFlagsOpt.IsNone && not attrs.IsEmpty then
-            let rhsIsFunction = isFunTy g overallPatTy
-            let lhsIsFunction = isFunTy g overallExprTy
-            let attrTgt =
-                match rhsIsFunction, lhsIsFunction with
-                | false, false when declaredTypars.IsEmpty -> AttributeTargets.Field ||| AttributeTargets.Property ||| AttributeTargets.ReturnValue
-                | _, _ -> AttributeTargets.Method ||| AttributeTargets.ReturnValue
-
-            TcAttributesWithPossibleTargets false cenv env attrTgt attrs |> ignore
+            TcAttributeTargetsOnLetBindings cenv env attrs overallPatTy overallExprTy (not declaredTypars.IsEmpty)
 
         CheckedBindingInfo(inlineFlag, valAttribs, xmlDoc, tcPatPhase2, explicitTyparInfo, nameToPrelimValSchemeMap, rhsExprChecked, argAndRetAttribs, overallPatTy, mBinding, debugPoint, isCompGen, literalValue, isFixed), tpenv
 
+// Note:
+// - Let bound values can only have attributes that uses AttributeTargets.Field ||| AttributeTargets.Property ||| AttributeTargets.ReturnValue
+// - Let function bindings can only have attributes that uses AttributeTargets.Method ||| AttributeTargets.ReturnValue
+and TcAttributeTargetsOnLetBindings (cenv: cenv) env attrs overallPatTy overallExprTy areTyparsDeclared =
+    let attrTgt =
+        if
+            // It's a type function:
+            //     let x<'a> = …
+            areTyparsDeclared
+            // It's a regular function-valued binding:
+            //     let f x = …
+            //     let f = fun x -> …
+            || isFunTy cenv.g overallPatTy
+            || isFunTy cenv.g overallExprTy
+        then
+            AttributeTargets.ReturnValue ||| AttributeTargets.Method
+        else
+            AttributeTargets.ReturnValue ||| AttributeTargets.Field ||| AttributeTargets.Property
+
+    TcAttributes cenv env attrTgt attrs |> ignore
+
 and TcLiteral (cenv: cenv) overallTy env tpenv (attrs, synLiteralValExpr) =
 
     let g = cenv.g
@@ -11230,7 +11245,7 @@ and TcLetBinding (cenv: cenv) isUse env containerInfo declKind tpenv (synBinds,
                 when List.lengthsEqAndForall2 typarRefEq generalizedTypars generalizedTypars' ->
                     v, pat
 
-            | _ when inlineFlag.MustInline ->
+            | _ when inlineFlag.ShouldInline ->
                 error(Error(FSComp.SR.tcInvalidInlineSpecification(), m))
 
             | TPat_query _ when HasFSharpAttribute g g.attrib_LiteralAttribute attrs ->
diff --git a/src/Compiler/Checking/CheckExpressions.fsi b/src/Compiler/Checking/CheckExpressions.fsi
index 852fee213e6..cc136eba754 100644
--- a/src/Compiler/Checking/CheckExpressions.fsi
+++ b/src/Compiler/Checking/CheckExpressions.fsi
@@ -256,7 +256,7 @@ type NormalizedBinding =
     | NormalizedBinding of
         visibility: SynAccess option *
         kind: SynBindingKind *
-        mustInline: bool *
+        shouldInline: bool *
         isMutable: bool *
         attribs: SynAttribute list *
         xmlDoc: XmlDoc *
@@ -430,6 +430,7 @@ val ComputeAccessRights:
 
 /// Compute the available access rights and module/entity compilation path for a paricular location in code
 val ComputeAccessAndCompPath:
+    g: TcGlobals ->
     env: TcEnv ->
     declKindOpt: DeclKind option ->
     m: range ->
diff --git a/src/Compiler/Checking/CheckIncrementalClasses.fs b/src/Compiler/Checking/CheckIncrementalClasses.fs
index 85262e72a4c..1424a8ef7f3 100644
--- a/src/Compiler/Checking/CheckIncrementalClasses.fs
+++ b/src/Compiler/Checking/CheckIncrementalClasses.fs
@@ -291,13 +291,15 @@ type IncrClassReprInfo =
     /// <param name='staticForcedFieldVars'>The vars forced to be fields due to static member bindings, instance initialization expressions or instance member bindings</param>
     /// <param name='instanceForcedFieldVars'>The vars forced to be fields due to instance member bindings</param>
     /// <param name='takenFieldNames'></param>
+    /// <param name='declKind'></param>
     /// <param name='bind'></param>
     member localRep.ChooseRepresentation (cenv: cenv, env: TcEnv, isStatic, isCtorArg,
                                             staticCtorInfo: StaticCtorInfo,
                                             ctorInfoOpt: IncrClassCtorInfo option,
                                             staticForcedFieldVars: FreeLocals,
                                             instanceForcedFieldVars: FreeLocals, 
-                                            takenFieldNames: Set<string>, 
+                                            takenFieldNames: Set<string>,
+                                            declKind: DeclKind,
                                             bind: Binding) = 
         let g = cenv.g 
         let v = bind.Var
@@ -387,7 +389,7 @@ type IncrClassReprInfo =
                 // it a "member" in the F# sense, but the F# spec says it is generated and it is reasonable to reflect on it.
                 let memberValScheme = ValScheme(id, prelimTyschemeG, Some valReprInfo, None, Some memberInfo, false, ValInline.Never, NormalVal, None, true (* isCompilerGenerated *), true (* isIncrClass *), false, false)
 
-                let methodVal = MakeAndPublishVal cenv env (Parent tcref, false, ModuleOrMemberBinding, ValNotInRecScope, memberValScheme, v.Attribs, XmlDoc.Empty, None, false) 
+                let methodVal = MakeAndPublishVal cenv env (Parent tcref, false, declKind, ValNotInRecScope, memberValScheme, v.Attribs, XmlDoc.Empty, None, false) 
 
                 reportIfUnused()
                 InMethod(isStatic, methodVal, valReprInfo)
@@ -395,9 +397,9 @@ type IncrClassReprInfo =
         repr, takenFieldNames
 
     /// Extend the known local representations by choosing a representation for a binding
-    member localRep.ChooseAndAddRepresentation(cenv, env, isStatic, isCtorArg, staticCtorInfo, ctorInfoOpt, staticForcedFieldVars, instanceForcedFieldVars, bind: Binding) = 
+    member localRep.ChooseAndAddRepresentation(cenv, env, isStatic, isCtorArg, staticCtorInfo, ctorInfoOpt, staticForcedFieldVars, instanceForcedFieldVars, declKind, bind: Binding) = 
         let v = bind.Var
-        let repr, takenFieldNames = localRep.ChooseRepresentation (cenv, env, isStatic, isCtorArg, staticCtorInfo, ctorInfoOpt, staticForcedFieldVars, instanceForcedFieldVars, localRep.TakenFieldNames, bind )
+        let repr, takenFieldNames = localRep.ChooseRepresentation (cenv, env, isStatic, isCtorArg, staticCtorInfo, ctorInfoOpt, staticForcedFieldVars, instanceForcedFieldVars, localRep.TakenFieldNames, declKind, bind )
         // OK, representation chosen, now add it 
         {localRep with 
             TakenFieldNames=takenFieldNames 
@@ -677,11 +679,10 @@ let MakeCtorForIncrClassConstructionPhase2C(
 
             (staticForcedFieldVars.FreeLocals, instanceForcedFieldVars.FreeLocals)
 
-
     // Compute the implicit construction side effects of single 
     // 'let' or 'let rec' binding in the implicit class construction sequence 
     let TransBind (reps: IncrClassReprInfo) (TBind(v, rhsExpr, spBind)) =
-        if v.MustInline then
+        if v.ShouldInline then
             error(Error(FSComp.SR.tcLocalClassBindingsCannotBeInline(), v.Range))
         let rhsExpr = reps.FixupIncrClassExprPhase2C cenv thisValOpt safeStaticInitInfo thisTyInst rhsExpr
             
@@ -772,7 +773,8 @@ let MakeCtorForIncrClassConstructionPhase2C(
             match dec with 
             | IncrClassBindingGroup(binds, isStatic, isRec) ->
                 let actions, reps, methodBinds = 
-                    let reps = (reps, binds) ||> List.fold (fun rep bind -> rep.ChooseAndAddRepresentation(cenv, env, isStatic, isCtorArg, staticCtorInfo, ctorInfoOpt, staticForcedFieldVars, instanceForcedFieldVars, bind)) // extend
+                    // let reps = (reps, binds) ||> List.fold (fun rep bind -> rep.ChooseAndAddRepresentation(cenv, env, isStatic, isCtorArg, staticCtorInfo, ctorInfoOpt, staticForcedFieldVars, instanceForcedFieldVars, (ClassLetBinding isStatic), bind)) // extend
+                    let reps = (reps, binds) ||> List.fold (fun rep bind -> rep.ChooseAndAddRepresentation(cenv, env, isStatic, isCtorArg, staticCtorInfo, ctorInfoOpt, staticForcedFieldVars, instanceForcedFieldVars, ModuleOrMemberBinding, bind)) // extend
                     if isRec then
                         // Note: the recursive calls are made via members on the object
                         // or via access to fields. This means the recursive loop is "broken", 
diff --git a/src/Compiler/Checking/NicePrint.fs b/src/Compiler/Checking/NicePrint.fs
index 985d3fbe22b..a09328222c4 100644
--- a/src/Compiler/Checking/NicePrint.fs
+++ b/src/Compiler/Checking/NicePrint.fs
@@ -495,7 +495,7 @@ module PrintTypes =
     let layoutAccessibilityCore (denv: DisplayEnv) accessibility =
         let isInternalCompPath x = 
             match x with 
-            | CompPath(ILScopeRef.Local, []) -> true 
+            | CompPath(ILScopeRef.Local, _, []) -> true 
             | _ -> false
         let (|Public|Internal|Private|) (TAccess p) = 
             match p with 
@@ -1254,7 +1254,7 @@ module PrintTastMemberOrVals =
     open PrintTypes 
 
     let mkInlineL denv (v: Val) nameL = 
-        if v.MustInline && not denv.suppressInlineKeyword then 
+        if v.ShouldInline && not denv.suppressInlineKeyword then 
             WordL.keywordInline ++ nameL 
         else 
             nameL
diff --git a/src/Compiler/Checking/PostInferenceChecks.fs b/src/Compiler/Checking/PostInferenceChecks.fs
index e9dee56e748..e15d9e9463f 100644
--- a/src/Compiler/Checking/PostInferenceChecks.fs
+++ b/src/Compiler/Checking/PostInferenceChecks.fs
@@ -1970,7 +1970,8 @@ and AdjustAccess isHidden (cpath: unit -> CompilationPath) access =
         let (TAccess l) = access
         // FSharp 1.0 bug 1908: Values hidden by signatures are implicitly at least 'internal'
         let scoref = cpath().ILScopeRef
-        TAccess(CompPath(scoref, []) :: l)
+        let sa = cpath().SyntaxAccess
+        TAccess(CompPath(scoref, sa, []) :: l)
     else
         access
 
@@ -2076,7 +2077,7 @@ and CheckBinding cenv env alwaysCheckNoReraise ctxt (TBind(v, bindRhs, _) as bin
         if cenv.reportErrors && isReturnsResumableCodeTy g v.TauType then
             if not (g.langVersion.SupportsFeature LanguageFeature.ResumableStateMachines) then
                 error(Error(FSComp.SR.tcResumableCodeNotSupported(), bind.Var.Range))
-            if not v.MustInline then
+            if not v.ShouldInline then
                 warning(Error(FSComp.SR.tcResumableCodeFunctionMustBeInline(), v.Range))
 
         if isReturnsResumableCodeTy g v.TauType then
@@ -2084,7 +2085,7 @@ and CheckBinding cenv env alwaysCheckNoReraise ctxt (TBind(v, bindRhs, _) as bin
         else
             env
 
-    CheckLambdas isTop (Some v) cenv env v.MustInline valReprInfo alwaysCheckNoReraise bindRhs v.Range v.Type ctxt
+    CheckLambdas isTop (Some v) cenv env v.ShouldInline valReprInfo alwaysCheckNoReraise bindRhs v.Range v.Type ctxt
 
 and CheckBindings cenv env binds =
     for bind in binds do
diff --git a/src/Compiler/Checking/SignatureConformance.fs b/src/Compiler/Checking/SignatureConformance.fs
index f24a93c5fc0..a058182c1a9 100644
--- a/src/Compiler/Checking/SignatureConformance.fs
+++ b/src/Compiler/Checking/SignatureConformance.fs
@@ -338,7 +338,7 @@ type Checker(g, amap, denv, remapInfo: SignatureRepackageInfo, checkingSig) =
             elif (implVal.CompiledName g.CompilerGlobalState) <> (sigVal.CompiledName g.CompilerGlobalState) then (err denv FSComp.SR.ValueNotContainedMutabilityCompiledNamesDiffer)
             elif implVal.DisplayName <> sigVal.DisplayName then (err denv FSComp.SR.ValueNotContainedMutabilityDisplayNamesDiffer)
             elif isLessAccessible implVal.Accessibility sigVal.Accessibility then (err denv FSComp.SR.ValueNotContainedMutabilityAccessibilityMore)
-            elif implVal.MustInline <> sigVal.MustInline then (err denv FSComp.SR.ValueNotContainedMutabilityInlineFlagsDiffer)
+            elif implVal.ShouldInline <> sigVal.ShouldInline then (err denv FSComp.SR.ValueNotContainedMutabilityInlineFlagsDiffer)
             elif implVal.LiteralValue <> sigVal.LiteralValue then (err denv FSComp.SR.ValueNotContainedMutabilityLiteralConstantValuesDiffer)
             elif implVal.IsTypeFunction <> sigVal.IsTypeFunction then (err denv FSComp.SR.ValueNotContainedMutabilityOneIsTypeFunction)
             else 
diff --git a/src/Compiler/Checking/SignatureHash.fs b/src/Compiler/Checking/SignatureHash.fs
index 156f64c5bdf..4acd53e0fad 100644
--- a/src/Compiler/Checking/SignatureHash.fs
+++ b/src/Compiler/Checking/SignatureHash.fs
@@ -113,7 +113,7 @@ module HashAccessibility =
     let isHiddenToObserver (TAccess access) (observer: ObserverVisibility) =
         let isInternalCompPath x =
             match x with
-            | CompPath(ILScopeRef.Local, []) -> true
+            | CompPath(ILScopeRef.Local, _, []) -> true
             | _ -> false
 
         match access with
diff --git a/src/Compiler/Checking/TailCallChecks.fs b/src/Compiler/Checking/TailCallChecks.fs
index ce6ab702bdc..aaeec0e81db 100644
--- a/src/Compiler/Checking/TailCallChecks.fs
+++ b/src/Compiler/Checking/TailCallChecks.fs
@@ -715,7 +715,7 @@ and CheckBinding cenv alwaysCheckNoReraise ctxt (TBind(v, bindRhs, _) as bind) :
         | Some info -> info
         | _ -> ValReprInfo.emptyValData
 
-    CheckLambdas isTop (Some v) cenv v.MustInline valReprInfo tailCall alwaysCheckNoReraise bindRhs v.Range v.Type ctxt
+    CheckLambdas isTop (Some v) cenv v.ShouldInline valReprInfo tailCall alwaysCheckNoReraise bindRhs v.Range v.Type ctxt
 
 and CheckBindings cenv binds =
     for bind in binds do
diff --git a/src/Compiler/Checking/import.fs b/src/Compiler/Checking/import.fs
index 7f1f13efda2..70e07fb26ec 100644
--- a/src/Compiler/Checking/import.fs
+++ b/src/Compiler/Checking/import.fs
@@ -567,7 +567,7 @@ and ImportILTypeDefs amap m scoref cpath enc (tdefs: ILTypeDefs) =
 /// the return ModuleOrNamespaceType will contain namespace entities for "System" and "Library", which in turn contain
 /// type definition entities for ["Char"; "Int32"]  and ["C"] respectively.  
 let ImportILAssemblyMainTypeDefs amap m scoref modul = 
-    modul.TypeDefs |> ImportILTypeDefs amap m scoref (CompPath(scoref, [])) [] 
+    modul.TypeDefs |> ImportILTypeDefs amap m scoref (CompPath(scoref, SyntaxAccess.Unknown, [])) [] 
 
 /// Import the "exported types" table for multi-module assemblies. 
 let ImportILAssemblyExportedType amap m auxModLoader (scoref: ILScopeRef) (exportedType: ILExportedTypeOrForwarder) = 
@@ -591,7 +591,7 @@ let ImportILAssemblyExportedType amap m auxModLoader (scoref: ILScopeRef) (expor
                     scoref, preTypeDef
             )
 
-        [ ImportILTypeDefList amap m (CompPath(scoref, [])) [] [(ns, (n, info))]  ]
+        [ ImportILTypeDefList amap m (CompPath(scoref, SyntaxAccess.Unknown, [])) [] [(ns, (n, info))]  ]
 
 /// Import the "exported types" table for multi-module assemblies. 
 let ImportILAssemblyExportedTypes amap m auxModLoader scoref (exportedTypes: ILExportedTypesAndForwarders) = 
diff --git a/src/Compiler/CodeGen/IlxGen.fs b/src/Compiler/CodeGen/IlxGen.fs
index 6a574fadc14..976bba1c82f 100644
--- a/src/Compiler/CodeGen/IlxGen.fs
+++ b/src/Compiler/CodeGen/IlxGen.fs
@@ -215,15 +215,17 @@ let CountStaticFieldDef = NewCounter "IL field definitions corresponding to valu
 let CountCallFuncInstructions = NewCounter "callfunc instructions (indirect calls)"
 
 /// Non-local information related to internals of code generation within an assembly
-type IlxGenIntraAssemblyInfo =
-    {
-        /// A table recording the generated name of the static backing fields for each mutable top level value where
-        /// we may need to take the address of that value, e.g. static mutable module-bound values which are structs. These are
-        /// only accessible intra-assembly. Across assemblies, taking the address of static mutable module-bound values is not permitted.
-        /// The key to the table is the method ref for the property getter for the value, which is a stable name for the Val's
-        /// that come from both the signature and the implementation.
-        StaticFieldInfo: ConcurrentDictionary<ILMethodRef, ILFieldSpec>
-    }
+///     A table recording the generated name of the static backing fields for each mutable top level value where
+///     we may need to take the address of that value, e.g. static mutable module-bound values which are structs. These are
+///     only accessible intra-assembly. Across assemblies, taking the address of static mutable module-bound values is not permitted.
+///     The key to the table is the method ref for the property getter for the value, which is a stable name for the Val's
+///     that come from both the signature and the implementation.
+type IlxGenIntraAssemblyInfo(staticFieldInfo: ConcurrentDictionary<ILMethodRef, ILFieldSpec>) =
+
+    static member Create() =
+        new IlxGenIntraAssemblyInfo(new ConcurrentDictionary<_, _>(HashIdentity.Structural))
+
+    member _.GetOrAddStaticFieldInfo(info: ILMethodRef, f: System.Func<ILMethodRef, ILFieldSpec>) = staticFieldInfo.GetOrAdd(info, f)
 
 /// Helper to make sure we take tailcalls in some situations
 type FakeUnit = | Fake
@@ -316,9 +318,6 @@ type cenv =
         /// Cache the generation of the "unit" type
         mutable ilUnitTy: ILType option
 
-        /// Other information from the emit of this assembly
-        intraAssemblyInfo: IlxGenIntraAssemblyInfo
-
         /// Cache methods with SecurityAttribute applied to them, to prevent unnecessary calls to ExistsInEntireHierarchyOfType
         casApplied: IDictionary<Stamp, bool>
 
@@ -410,7 +409,7 @@ let CompLocForSubModuleOrNamespace cloc (submod: ModuleOrNamespace) =
             Namespace = Some(mkTopName cloc.Namespace n)
         }
 
-let CompLocForFixedPath fragName qname (CompPath(sref, cpath)) =
+let CompLocForFixedPath fragName qname (CompPath(sref, _, cpath)) =
     let ns, t =
         cpath
         |> List.takeUntil (fun (_, mkind) ->
@@ -490,23 +489,31 @@ let TypeRefForCompLoc cloc =
 let mkILTyForCompLoc cloc =
     mkILNonGenericBoxedTy (TypeRefForCompLoc cloc)
 
-let ComputeMemberAccess hidden =
-    if hidden then
+/// Compute visibility for type members
+/// based on hidden and acessibility from the source code
+/// when hidden and realsig is specified then
+///     as typed in source code, I.e internal or public
+/// when hidden and not realsig is specified then
+///     then they are internal, old behaviour (anything not public is internal)
+/// otherwise it is public, by definition
+let ComputeMemberAccess hidden (accessibility: Accessibility) realsig =
+
+    if (not accessibility.IsPublic) && realsig then
+        accessibility.AsILMemberAccess()
+    elif hidden then
         ILMemberAccess.Assembly
     else
         ILMemberAccess.Public
 
-// Under --publicasinternal change types from Public to Private (internal for types)
-let ComputePublicTypeAccess () = ILTypeDefAccess.Public
+let ComputeTypeAccess (tref: ILTypeRef) hidden (accessibility: Accessibility) realsig =
 
-let ComputeTypeAccess (tref: ILTypeRef) hidden =
     match tref.Enclosing with
     | [] ->
         if hidden then
             ILTypeDefAccess.Private
         else
-            ComputePublicTypeAccess()
-    | _ -> ILTypeDefAccess.Nested(ComputeMemberAccess hidden)
+            ILTypeDefAccess.Public
+    | _ -> ILTypeDefAccess.Nested(ComputeMemberAccess hidden accessibility realsig)
 
 //--------------------------------------------------------------------------
 // TypeReprEnv
@@ -814,17 +821,22 @@ and GenTypeArgs cenv m tyenv tyargs = GenTypeArgsAux cenv m tyenv tyargs
 // Computes the location where the static field for a value lives.
 //     - Literals go in their type/module.
 //     - For interactive code, we always place fields in their type/module with an accurate name
-let GenFieldSpecForStaticField (isInteractive, g, ilContainerTy, vspec: Val, nm, m, cloc, ilTy) =
-    if isInteractive || HasFSharpAttribute g g.attrib_LiteralAttribute vspec.Attribs then
-        let fieldName = vspec.CompiledName g.CompilerGlobalState
+let GenFieldSpecForStaticField (isInteractive, (g: TcGlobals), ilContainerTy, vspec: Val, nm, m, cloc, ilTy) =
 
-        let fieldName =
-            if isInteractive then
-                CompilerGeneratedName fieldName
-            else
-                fieldName
+    let fieldName = vspec.CompiledName g.CompilerGlobalState
 
+    if HasFSharpAttribute g g.attrib_LiteralAttribute vspec.Attribs then
         mkILFieldSpecInTy (ilContainerTy, fieldName, ilTy)
+    elif isInteractive then
+        mkILFieldSpecInTy (ilContainerTy, CompilerGeneratedName fieldName, ilTy)
+    elif g.realsig then
+        assert (g.CompilerGlobalState |> Option.isSome)
+
+        mkILFieldSpecInTy (
+            ilContainerTy,
+            CompilerGeneratedName(g.CompilerGlobalState.Value.IlxGenNiceNameGenerator.FreshCompilerGeneratedName(nm, m)),
+            ilTy
+        )
     else
         let fieldName =
             // Ensure that we have an g.CompilerGlobalState
@@ -1150,6 +1162,18 @@ and IlxGenEnv =
         /// Indicates the default "place" for stuff we're currently generating
         cloc: CompileLocation
 
+        /// Indicates the default "place" for initialization stuff we're currently generating
+        initClassCompLoc: CompileLocation option
+
+        /// Per sourcefile initclass fieldspec
+        initClassFieldSpec: Lazy<ILFieldSpec> option
+
+        /// Indicates the name used for static initialization fields
+        initFieldName: string
+
+        /// Indicates the name used for static initialization method
+        staticInitializationName: string
+
         /// The sequel to use for an "early exit" in a state machine, e.g. a return from the middle of an
         /// async block
         exitSequel: sequel
@@ -1194,6 +1218,11 @@ and IlxGenEnv =
 
         /// Collection of code-gen functions where each inner array represents codegen (method bodies) functions for a single file
         delayedFileGenReverse: list<(unit -> unit)[]>
+
+        /// Other information from the emit of this assembly
+        intraAssemblyInfo: IlxGenIntraAssemblyInfo
+
+        realsig: bool
     }
 
     override _.ToString() = "<IlxGenEnv>"
@@ -1217,6 +1246,15 @@ let EnvForTycon tps eenv =
         tyenv = eenv.tyenv.ForTycon tps
     }
 
+let AddEnclosingToEnv eenv enclosing name ns =
+    { eenv with
+        cloc =
+            { eenv.cloc with
+                Enclosing = enclosing @ [ name ]
+                Namespace = ns
+            }
+    }
+
 let AddTyparsToEnv typars (eenv: IlxGenEnv) =
     { eenv with
         tyenv = eenv.tyenv.Add typars
@@ -1454,20 +1492,23 @@ let ComputeFieldSpecForVal
 
     match optIntraAssemblyInfo with
     | None -> generate ()
-    | Some iai -> iai.StaticFieldInfo.GetOrAdd(ilGetterMethRef, (fun _ -> generate ()))
+    | Some intraAssemblyInfo -> intraAssemblyInfo.GetOrAddStaticFieldInfo(ilGetterMethRef, (fun _ -> generate ()))
 
 /// Compute the representation information for an F#-declared value (not a member nor a function).
 /// Mutable and literal static fields must have stable names and live in the "public" location
-let ComputeStorageForFSharpValue amap (g: TcGlobals) cloc optIntraAssemblyInfo optShadowLocal isInteractive returnTy (vref: ValRef) m =
-    let nm = vref.CompiledName g.CompilerGlobalState
+let ComputeStorageForFSharpValue cenv cloc optIntraAssemblyInfo optShadowLocal isInteractive returnTy (vref: ValRef) m =
+    let nm = vref.CompiledName cenv.g.CompilerGlobalState
     let vspec = vref.Deref
 
     let ilTy =
-        GenType amap m TypeReprEnv.Empty returnTy (* TypeReprEnv.Empty ok: not a field in a generic class *)
+        GenType cenv m TypeReprEnv.Empty returnTy (* TypeReprEnv.Empty ok: not a field in a generic class *)
 
     let ilTyForProperty = mkILTyForCompLoc cloc
     let attribs = vspec.Attribs
-    let hasLiteralAttr = HasFSharpAttribute g g.attrib_LiteralAttribute attribs
+
+    let hasLiteralAttr =
+        HasFSharpAttribute cenv.g cenv.g.attrib_LiteralAttribute attribs
+
     let ilTypeRefForProperty = ilTyForProperty.TypeRef
 
     let ilGetterMethRef =
@@ -1477,7 +1518,7 @@ let ComputeStorageForFSharpValue amap (g: TcGlobals) cloc optIntraAssemblyInfo o
         mkILMethRef (ilTypeRefForProperty, ILCallingConv.Static, "set_" + nm, 0, [ ilTy ], ILType.Void)
 
     let ilFieldSpec =
-        ComputeFieldSpecForVal(optIntraAssemblyInfo, isInteractive, g, ilTyForProperty, vspec, nm, m, cloc, ilTy, ilGetterMethRef)
+        ComputeFieldSpecForVal(optIntraAssemblyInfo, isInteractive, cenv.g, ilTyForProperty, vspec, nm, m, cloc, ilTy, ilGetterMethRef)
 
     StaticPropertyWithField(ilFieldSpec, vref, hasLiteralAttr, ilTyForProperty, nm, ilTy, ilGetterMethRef, ilSetterMethRef, optShadowLocal)
 
@@ -1539,7 +1580,6 @@ let IsFSharpValCompiledAsMethod g (v: Val) =
 let ComputeStorageForValWithValReprInfo
     (
         cenv,
-        g,
         optIntraAssemblyInfo: IlxGenIntraAssemblyInfo option,
         isInteractive,
         optShadowLocal,
@@ -1547,7 +1587,11 @@ let ComputeStorageForValWithValReprInfo
         cloc
     ) =
 
-    if isUnitTy g vref.Type && not vref.IsMemberOrModuleBinding && not vref.IsMutable then
+    if
+        isUnitTy cenv.g vref.Type
+        && not vref.IsMemberOrModuleBinding
+        && not vref.IsMutable
+    then
         Null
     else
         let valReprInfo =
@@ -1563,7 +1607,7 @@ let ComputeStorageForValWithValReprInfo
             | Some a -> a
 
         let m = vref.Range
-        let nm = vref.CompiledName g.CompilerGlobalState
+        let nm = vref.CompiledName cenv.g.CompilerGlobalState
 
         if vref.Deref.IsCompiledAsStaticPropertyWithoutField then
             let nm = "get_" + nm
@@ -1579,35 +1623,34 @@ let ComputeStorageForValWithValReprInfo
             //
             // REVIEW: This call to GetValReprTypeInFSharpForm is only needed to determine if this is a (type) function or a value
             // We should just look at the arity
-            match GetValReprTypeInFSharpForm g valReprInfo vref.Type vref.Range with
+            match GetValReprTypeInFSharpForm cenv.g valReprInfo vref.Type vref.Range with
             | [], [], returnTy, _ when not vref.IsMember ->
-                ComputeStorageForFSharpValue cenv g cloc optIntraAssemblyInfo optShadowLocal isInteractive returnTy vref m
+                ComputeStorageForFSharpValue cenv cloc optIntraAssemblyInfo optShadowLocal isInteractive returnTy vref m
             | _ ->
                 match vref.MemberInfo with
                 | Some memberInfo when not vref.IsExtensionMember -> ComputeStorageForFSharpMember cenv valReprInfo memberInfo vref m
                 | _ -> ComputeStorageForFSharpFunctionOrFSharpExtensionMember cenv cloc valReprInfo vref m
 
 /// Determine how an F#-declared value, function or member is represented, if it is in the assembly being compiled.
-let ComputeAndAddStorageForLocalValWithValReprInfo (cenv, g, intraAssemblyFieldTable, isInteractive, optShadowLocal) cloc (v: Val) eenv =
+let ComputeAndAddStorageForLocalValWithValReprInfo (cenv, intraAssemblyFieldTable, isInteractive, optShadowLocal) cloc (v: Val) eenv =
     let storage =
-        ComputeStorageForValWithValReprInfo(cenv, g, Some intraAssemblyFieldTable, isInteractive, optShadowLocal, mkLocalValRef v, cloc)
+        ComputeStorageForValWithValReprInfo(cenv, Some intraAssemblyFieldTable, isInteractive, optShadowLocal, mkLocalValRef v, cloc)
 
-    AddStorageForVal g (v, notlazy storage) eenv
+    AddStorageForVal cenv.g (v, notlazy storage) eenv
 
 /// Determine how an F#-declared value, function or member is represented, if it is an external assembly.
-let ComputeStorageForNonLocalVal cenv g cloc modref (v: Val) =
+let ComputeStorageForNonLocalVal cenv cloc modref (v: Val) =
     match v.ValReprInfo with
     | None -> error (InternalError("ComputeStorageForNonLocalVal, expected an ValReprInfo for " + v.LogicalName, v.Range))
-    | Some _ -> ComputeStorageForValWithValReprInfo(cenv, g, None, false, NoShadowLocal, mkNestedValRef modref v, cloc)
+    | Some _ -> ComputeStorageForValWithValReprInfo(cenv, None, false, NoShadowLocal, mkNestedValRef modref v, cloc)
 
 /// Determine how all the F#-declared top level values, functions and members are represented, for an external module or namespace.
-let rec AddStorageForNonLocalModuleOrNamespaceRef cenv g cloc acc (modref: ModuleOrNamespaceRef) (modul: ModuleOrNamespace) =
+let rec AddStorageForNonLocalModuleOrNamespaceRef cenv cloc acc (modref: ModuleOrNamespaceRef) (modul: ModuleOrNamespace) =
     let acc =
         (acc, modul.ModuleOrNamespaceType.ModuleAndNamespaceDefinitions)
         ||> List.fold (fun acc smodul ->
             AddStorageForNonLocalModuleOrNamespaceRef
                 cenv
-                g
                 (CompLocForSubModuleOrNamespace cloc smodul)
                 acc
                 (modref.NestedTyconRef smodul)
@@ -1616,12 +1659,12 @@ let rec AddStorageForNonLocalModuleOrNamespaceRef cenv g cloc acc (modref: Modul
     let acc =
         (acc, modul.ModuleOrNamespaceType.AllValsAndMembers)
         ||> Seq.fold (fun acc v ->
-            AddStorageForVal g (v, InterruptibleLazy(fun _ -> ComputeStorageForNonLocalVal cenv g cloc modref v)) acc)
+            AddStorageForVal cenv.g (v, InterruptibleLazy(fun _ -> ComputeStorageForNonLocalVal cenv cloc modref v)) acc)
 
     acc
 
 /// Determine how all the F#-declared top level values, functions and members are represented, for an external assembly.
-let AddStorageForExternalCcu cenv g eenv (ccu: CcuThunk) =
+let AddStorageForExternalCcu cenv eenv (ccu: CcuThunk) =
     if not ccu.IsFSharp then
         eenv
     else
@@ -1632,7 +1675,7 @@ let AddStorageForExternalCcu cenv g eenv (ccu: CcuThunk) =
                 (fun smodul acc ->
                     let cloc = CompLocForSubModuleOrNamespace cloc smodul
                     let modref = mkNonLocalCcuRootEntityRef ccu smodul
-                    AddStorageForNonLocalModuleOrNamespaceRef cenv g cloc acc modref smodul)
+                    AddStorageForNonLocalModuleOrNamespaceRef cenv cloc acc modref smodul)
                 ccu.RootModulesAndNamespaces
                 eenv
 
@@ -1641,7 +1684,7 @@ let AddStorageForExternalCcu cenv g eenv (ccu: CcuThunk) =
 
             (eenv, ccu.Contents.ModuleOrNamespaceType.AllValsAndMembers)
             ||> Seq.fold (fun acc v ->
-                AddStorageForVal g (v, InterruptibleLazy(fun _ -> ComputeStorageForNonLocalVal cenv g cloc eref v)) acc)
+                AddStorageForVal cenv.g (v, InterruptibleLazy(fun _ -> ComputeStorageForNonLocalVal cenv cloc eref v)) acc)
 
         eenv
 
@@ -1662,8 +1705,8 @@ let rec AddBindingsForLocalModuleOrNamespaceType allocVal cloc eenv (mty: Module
     eenv
 
 /// Record how all the top level F#-declared values, functions and members are represented, for a set of referenced assemblies.
-let AddExternalCcusToIlxGenEnv cenv g eenv ccus =
-    List.fold (AddStorageForExternalCcu cenv g) eenv ccus
+let AddExternalCcusToIlxGenEnv cenv eenv ccus =
+    List.fold (AddStorageForExternalCcu cenv) eenv ccus
 
 /// Record how all the unrealized abstract slots are represented, for a type definition.
 let AddBindingsForTycon allocVal (cloc: CompileLocation) (tycon: Tycon) eenv =
@@ -1759,21 +1802,11 @@ and AddBindingsForModuleOrNamespaceBinding allocVal cloc x eenv =
 /// into the stored results for the whole CCU.
 /// isIncrementalFragment = true --> "typed input"
 /// isIncrementalFragment = false --> "#load"
-let AddIncrementalLocalAssemblyFragmentToIlxGenEnv
-    (
-        cenv: cenv,
-        isIncrementalFragment,
-        g,
-        ccu,
-        fragName,
-        intraAssemblyInfo,
-        eenv,
-        implFiles
-    ) =
+let AddIncrementalLocalAssemblyFragmentToIlxGenEnv (cenv: cenv, isIncrementalFragment, ccu, fragName, eenv, implFiles) =
     let cloc = CompLocForFragment fragName ccu
 
     let allocVal =
-        ComputeAndAddStorageForLocalValWithValReprInfo(cenv, g, intraAssemblyInfo, true, NoShadowLocal)
+        ComputeAndAddStorageForLocalValWithValReprInfo(cenv, eenv.intraAssemblyInfo, true, NoShadowLocal)
 
     (eenv, implFiles)
     ||> List.fold (fun eenv implFile ->
@@ -1928,6 +1961,8 @@ type TypeDefBuilder(tdef: ILTypeDef, tdefDiscards) =
 
         this
 
+    member _.ILTypeDef = tdef
+
 and TypeDefsBuilder() =
 
     let tdefs =
@@ -2093,7 +2128,7 @@ type AnonTypeGenerationTable() =
 
             let tycon =
                 let lmtyp = MaybeLazy.Strict(Construct.NewEmptyModuleOrNamespaceType ModuleOrType)
-                let cpath = CompPath(ilTypeRef.Scope, [])
+                let cpath = CompPath(ilTypeRef.Scope, SyntaxAccess.Unknown, [])
 
                 Construct.NewTycon(
                     Some cpath,
@@ -2264,7 +2299,10 @@ and AssemblyBuilder(cenv: cenv, anonTypeTable: AnonTypeGenerationTable) as mgbuf
                 let vtdef = mkRawDataValueTypeDef g.iltyp_ValueType (name, size, 0us)
                 let vtref = NestedTypeRefForCompLoc cloc vtdef.Name
                 let vtspec = mkILTySpec (vtref, [])
-                let vtdef = vtdef.WithAccess(ComputeTypeAccess vtref true)
+
+                let vtdef =
+                    vtdef.WithAccess(ComputeTypeAccess vtref true taccessInternal cenv.g.realsig)
+
                 mgbuf.AddTypeDef(vtref, vtdef, false, true, None)
                 vtspec),
             keyComparer = HashIdentity.Structural
@@ -2329,6 +2367,8 @@ and AssemblyBuilder(cenv: cenv, anonTypeTable: AnonTypeGenerationTable) as mgbuf
             .FindNestedTypeDefsBuilder(tref.Enclosing)
             .AddTypeDef(tdef, eliminateIfEmpty, addAtEnd, tdefDiscards)
 
+    member _.FindNestedTypeDefBuilder(tref: ILTypeRef) = gtdefs.FindNestedTypeDefBuilder(tref)
+
     member _.GetCurrentFields(tref: ILTypeRef) =
         gtdefs.FindNestedTypeDefBuilder(tref).GetCurrentFields()
 
@@ -6115,7 +6155,7 @@ and GenStructStateMachine cenv cgbuf eenvouter (res: LoweredStateMachine) sequel
                 ) do
                 // Suppress the "ResumptionDynamicInfo" from generated state machines
                 if templateFld.LogicalName <> "ResumptionDynamicInfo" then
-                    let access = ComputeMemberAccess false
+                    let access = ComputeMemberAccess false taccessPublic cenv.g.realsig
                     let fty = GenType cenv m eenvinner.tyenv templateFld.FieldType
 
                     let fdef =
@@ -6136,7 +6176,7 @@ and GenStructStateMachine cenv cgbuf eenvouter (res: LoweredStateMachine) sequel
 
             // Fields for captured variables
             for ilCloFreeVar in ilCloFreeVars do
-                let access = ComputeMemberAccess false
+                let access = ComputeMemberAccess false taccessPublic cenv.g.realsig
 
                 let fdef =
                     ILFieldDef(
@@ -6181,7 +6221,7 @@ and GenStructStateMachine cenv cgbuf eenvouter (res: LoweredStateMachine) sequel
         )
             .WithSealed(true)
             .WithSpecialName(true)
-            .WithAccess(ComputeTypeAccess ilCloTypeRef true)
+            .WithAccess(ComputeTypeAccess ilCloTypeRef true taccessInternal cenv.g.realsig)
             .WithLayout(ILTypeDefLayout.Auto)
             .WithEncoding(ILDefaultPInvokeEncoding.Auto)
             .WithInitSemantics(ILTypeInit.BeforeField)
@@ -6610,7 +6650,7 @@ and GenClosureTypeDefs
             .WithSealed(true)
             .WithSerializable(true)
             .WithSpecialName(true)
-            .WithAccess(ComputeTypeAccess tref true)
+            .WithAccess(ComputeTypeAccess tref true taccessInternal cenv.g.realsig)
             .WithLayout(ILTypeDefLayout.Auto)
             .WithEncoding(ILDefaultPInvokeEncoding.Auto)
             .WithInitSemantics(ILTypeInit.BeforeField)
@@ -6797,13 +6837,12 @@ and GenFreevar cenv m eenvouter tyenvinner (fv: Val) =
 #endif
     | _ -> GenType cenv m tyenvinner fv.Type
 
-and GetIlxClosureFreeVars cenv m (thisVars: ValRef list) boxity eenvouter takenNames expr =
+and GetIlxClosureFreeVars cenv m (thisVars: ValRef list) boxity eenv takenNames expr =
     let g = cenv.g
 
     // Choose a base name for the closure
     let basename =
-        let boundv =
-            eenvouter.letBoundVars |> List.tryFind (fun v -> not v.IsCompilerGenerated)
+        let boundv = eenv.letBoundVars |> List.tryFind (fun v -> not v.IsCompilerGenerated)
 
         match boundv with
         | Some v -> v.CompiledName cenv.g.CompilerGlobalState
@@ -6821,6 +6860,7 @@ and GetIlxClosureFreeVars cenv m (thisVars: ValRef list) boxity eenvouter takenN
     let ilCloTypeRef =
         // FSharp 1.0 bug 3404: System.Reflection doesn't like '.' and '`' in type names
         let basenameSafeForUseAsTypename = CleanUpGeneratedTypeName basename
+
         let suffixmark = expr.Range
 
         let cloName =
@@ -6828,14 +6868,14 @@ and GetIlxClosureFreeVars cenv m (thisVars: ValRef list) boxity eenvouter takenN
             assert (g.CompilerGlobalState |> Option.isSome)
             g.CompilerGlobalState.Value.StableNameGenerator.GetUniqueCompilerGeneratedName(basenameSafeForUseAsTypename, suffixmark, uniq)
 
-        NestedTypeRefForCompLoc eenvouter.cloc cloName
+        NestedTypeRefForCompLoc eenv.cloc cloName
 
     // Collect the free variables of the closure
     let cloFreeVarResults =
         let opts = CollectTyparsAndLocalsWithStackGuard()
 
         let opts =
-            match eenvouter.tyenv.TemplateReplacement with
+            match eenv.tyenv.TemplateReplacement with
             | None -> opts
             | Some(tcref, _, typars, _) -> opts.WithTemplateReplacement(tyconRefEq g tcref, typars)
 
@@ -6850,7 +6890,7 @@ and GetIlxClosureFreeVars cenv m (thisVars: ValRef list) boxity eenvouter takenN
         freeLocals
         |> List.filter (fun fv ->
             (thisVars |> List.forall (fun v -> not (valRefEq g (mkLocalValRef fv) v)))
-            && (match StorageForVal m fv eenvouter with
+            && (match StorageForVal m fv eenv with
                 | StaticPropertyWithField _
                 | StaticProperty _
                 | Method _
@@ -6862,14 +6902,14 @@ and GetIlxClosureFreeVars cenv m (thisVars: ValRef list) boxity eenvouter takenN
     let cloFreeTyvars =
         (cloFreeVarResults.FreeTyvars, freeLocals)
         ||> List.fold (fun ftyvs fv ->
-            match StorageForVal m fv eenvouter with
+            match StorageForVal m fv eenv with
             | Env(_, _, Some(moreFtyvs, _))
             | Local(_, _, Some(moreFtyvs, _)) -> unionFreeTyvars ftyvs moreFtyvs
             | _ -> ftyvs)
 
     let cloFreeTyvars = cloFreeTyvars.FreeTypars |> Zset.elements
 
-    let eenvinner = eenvouter |> EnvForTypars cloFreeTyvars
+    let eenvinner = eenv |> EnvForTypars cloFreeTyvars
 
     let ilCloTyInner =
         let ilCloGenericParams = GenGenericParams cenv eenvinner cloFreeTyvars
@@ -6905,13 +6945,13 @@ and GetIlxClosureFreeVars cenv m (thisVars: ValRef list) boxity eenvouter takenN
         (cloFreeVars, names)
         ||> List.map2 (fun fv nm ->
             let localCloInfo =
-                match StorageForVal m fv eenvouter with
+                match StorageForVal m fv eenv with
                 | Local(_, _, localCloInfo)
                 | Env(_, _, localCloInfo) -> localCloInfo
                 | _ -> None
 
             let ilFv =
-                mkILFreeVar (nm, fv.IsCompilerGenerated, GenFreevar cenv m eenvouter eenvinner.tyenv fv)
+                mkILFreeVar (nm, fv.IsCompilerGenerated, GenFreevar cenv m eenv eenvinner.tyenv fv)
 
             let storage =
                 let ilField = mkILFieldSpecInTy (ilCloTyInner, ilFv.fvName, ilFv.fvType)
@@ -8074,7 +8114,7 @@ and GenLetRecFixup cenv cgbuf eenv (ilxCloSpec: IlxClosureSpec, e, ilField: ILFi
     CG.EmitInstr cgbuf (pop 2) Push0 (mkNormalStfld (mkILFieldSpec (ilField.FieldRef, ilxCloSpec.ILType)))
 
 /// Generate letrec bindings
-and GenLetRecBindings cenv (cgbuf: CodeGenBuffer) eenv (allBinds: Bindings, m) =
+and GenLetRecBindings cenv (cgbuf: CodeGenBuffer) eenv (allBinds: Bindings, m) (dict: Dictionary<Stamp, ILTypeRef> option) =
 
     // 'let rec' bindings are always considered to be in loops, that is each may have backward branches for the
     // tailcalls back to the entry point. This means we don't rely on zero-init of mutable locals
@@ -8146,6 +8186,23 @@ and GenLetRecBindings cenv (cgbuf: CodeGenBuffer) eenv (allBinds: Bindings, m) =
 
     let fixups = ref []
 
+    let updateForwardReferenceSet (bind: Binding) (forwardReferenceSet: Zset<Val>) =
+        // Record the variable as defined
+        let forwardReferenceSet = Zset.remove bind.Var forwardReferenceSet
+
+        // Execute and discard any fixups that can now be committed
+        let newFixups =
+            fixups.Value
+            |> List.filter (fun (boundv, fv, action) ->
+                if (Zset.contains boundv forwardReferenceSet || Zset.contains fv forwardReferenceSet) then
+                    true
+                else
+                    action ()
+                    false)
+
+        fixups.Value <- newFixups
+        forwardReferenceSet
+
     let recursiveVars =
         Zset.addList (bindsPossiblyRequiringFixup |> List.map (fun v -> v.Var)) (Zset.empty valOrder)
 
@@ -8164,39 +8221,74 @@ and GenLetRecBindings cenv (cgbuf: CodeGenBuffer) eenv (allBinds: Bindings, m) =
                          "internal error: should never need to set non-delayed recursive val: "
                          + bind.Var.LogicalName
                      )))
+
             // Record the variable as defined
             let forwardReferenceSet = Zset.remove bind.Var forwardReferenceSet
             forwardReferenceSet)
 
-    // Generate the actual bindings
-    let _ =
-        (recursiveVars, allBinds)
-        ||> List.fold (fun forwardReferenceSet (bind: Binding) ->
-            GenBinding cenv cgbuf eenv bind false
+    let getStampForVal (v: Val) =
+        match v.HasDeclaringEntity with
+        | false -> 0L
+        | true -> v.DeclaringEntity.Deref.Stamp
 
-            // Record the variable as defined
-            let forwardReferenceSet = Zset.remove bind.Var forwardReferenceSet
+    let groupBinds =
+        let rec loopAllBinds bindings remainder =
+            match remainder with
+            | [] -> bindings |> List.rev
+            | _ ->
+                let stamp = remainder |> List.head |> (fun (TBind(v, _, _)) -> getStampForVal v)
 
-            // Execute and discard any fixups that can now be committed
-            let newFixups =
-                fixups.Value
-                |> List.filter (fun (boundv, fv, action) ->
-                    if (Zset.contains boundv forwardReferenceSet || Zset.contains fv forwardReferenceSet) then
-                        true
-                    else
-                        action ()
-                        false)
+                let taken =
+                    remainder |> List.takeWhile (fun (TBind(v, _, _)) -> stamp = getStampForVal v)
 
-            fixups.Value <- newFixups
+                let remainder =
+                    remainder |> List.skipWhile (fun (TBind(v, _, _)) -> stamp = getStampForVal v)
 
-            forwardReferenceSet)
+                loopAllBinds (taken :: bindings) remainder
+
+        loopAllBinds [ [] ] allBinds
+
+    let _ =
+        (recursiveVars, groupBinds)
+        ||> List.fold (fun forwardReferenceSet (binds: Binding list) ->
+            match dict, cenv.g.realsig, binds with
+            | _, false, _
+            | None, _, _
+            | _, _, [] ->
+                (forwardReferenceSet, binds)
+                ||> List.fold (fun forwardReferenceSet (bind: Binding) ->
+                    GenBinding cenv cgbuf eenv bind false
+                    updateForwardReferenceSet bind forwardReferenceSet)
+            | Some dict, true, _ ->
+                let (TBind(v, _, _)) = binds |> List.head
+
+                match dict.TryGetValue(getStampForVal v) with
+                | false, _ ->
+                    (forwardReferenceSet, binds)
+                    ||> List.fold (fun forwardReferenceSet (bind: Binding) ->
+                        GenBinding cenv cgbuf eenv bind false
+                        updateForwardReferenceSet bind forwardReferenceSet)
+                | true, tref ->
+                    CodeGenInitMethod
+                        cenv
+                        cgbuf
+                        (AddEnclosingToEnv eenv tref.Enclosing tref.Name None)
+                        tref
+                        (fun cgbuf eenv ->
+                            // Generate chunks of non-nested bindings together to allow recursive fixups.
+                            GenLetRecBindings cenv cgbuf eenv (binds, m) None
+                            CG.EmitInstr cgbuf (pop 0) Push0 I_ret)
+                        m
+
+                    (forwardReferenceSet, binds)
+                    ||> List.fold (fun forwardReferenceSet (bind: Binding) -> updateForwardReferenceSet bind forwardReferenceSet))
 
     ()
 
 and GenLetRec cenv cgbuf eenv (binds, body, m) sequel =
     let _, endMark as scopeMarks = StartLocalScope "letrec" cgbuf
     let eenv = AllocStorageForBinds cenv cgbuf scopeMarks eenv binds
-    GenLetRecBindings cenv cgbuf eenv (binds, m)
+    GenLetRecBindings cenv cgbuf eenv (binds, m) None
     GenExpr cenv cgbuf eenv body (EndLocalScope(sequel, endMark))
 
 //-------------------------------------------------------------------------
@@ -8212,17 +8304,22 @@ and GenBinding cenv cgbuf eenv (bind: Binding) (isStateVar: bool) =
     GenBindingAfterDebugPoint cenv cgbuf eenv bind isStateVar None
 
 and ComputeMethodAccessRestrictedBySig eenv vspec =
+    let vspec =
+        if eenv.realsig then
+            DoRemapVal eenv.sigToImplRemapInfo vspec
+        else
+            vspec
+
+    let isHiddenBySignatureVal = IsHiddenVal eenv.sigToImplRemapInfo vspec
+
     let isHidden =
-        // Anything hidden by a signature gets assembly visibility
-        IsHiddenVal eenv.sigToImplRemapInfo vspec
-        ||
+        isHiddenBySignatureVal
         // Anything that's not a module or member binding gets assembly visibility
-        not vspec.IsMemberOrModuleBinding
-        ||
+        || not vspec.IsMemberOrModuleBinding
         // Compiler generated members for class function 'let' bindings get assembly visibility
-        vspec.IsIncrClassGeneratedMember
+        || vspec.IsIncrClassGeneratedMember
 
-    ComputeMemberAccess isHidden
+    ComputeMemberAccess isHidden vspec.Accessibility eenv.realsig
 
 and GenBindingAfterDebugPoint cenv cgbuf eenv bind isStateVar startMarkOpt =
     let g = cenv.g
@@ -8249,12 +8346,13 @@ and GenBindingAfterDebugPoint cenv cgbuf eenv bind isStateVar startMarkOpt =
 
     let access = ComputeMethodAccessRestrictedBySig eenv vspec
 
+    // because of reflection back-compatability private constructors are treated the same as internal constructors
     // Workaround for .NET and Visual Studio restriction w.r.t debugger type proxys
-    // Mark internal constructors in internal classes as public.
+    // Mark internal and private constructors in internal classes as public.
     let access =
+        // private and internal constructors from source are treated the same
         if
-            access = ILMemberAccess.Assembly
-            && vspec.IsConstructor
+            vspec.IsConstructor
             && IsHiddenTycon eenv.sigToImplRemapInfo vspec.MemberApparentEntity.Deref
         then
             ILMemberAccess.Public
@@ -8407,8 +8505,9 @@ and GenBindingAfterDebugPoint cenv cgbuf eenv bind isStateVar startMarkOpt =
 
         /// Generate a static field definition...
         let ilFieldDefs =
-            let access =
-                ComputeMemberAccess(not hasLiteralAttr || IsHiddenVal eenv.sigToImplRemapInfo vspec)
+            let hidden = not hasLiteralAttr || IsHiddenVal eenv.sigToImplRemapInfo vspec
+
+            let access = ComputeMemberAccess hidden vspec.Accessibility cenv.g.realsig
 
             let ilFieldDef = mkILStaticField (fspec.Name, fty, None, None, access)
 
@@ -9718,17 +9817,15 @@ and AllocValForBind cenv cgbuf (scopeMarks: Mark * Mark) eenv (TBind(v, repr, _)
     | Some _ -> None, AllocValReprWithinExpr cenv cgbuf (snd scopeMarks) eenv.cloc v eenv
 
 and AllocValReprWithinExpr cenv cgbuf endMark cloc v eenv =
-    let g = cenv.g
-
     // decide whether to use a shadow local or not
     let useShadowLocal =
         cenv.options.generateDebugSymbols
         && not cenv.options.localOptimizationsEnabled
         && not v.IsCompilerGenerated
         && not v.IsMutable
-        &&
         // Don't use shadow locals for things like functions which are not compiled as static values/properties
-        IsCompiledAsStaticProperty g v
+        && (not eenv.realsig)
+        && IsCompiledAsStaticProperty cenv.g v
 
     let optShadowLocal, eenv =
         if useShadowLocal then
@@ -9738,7 +9835,7 @@ and AllocValReprWithinExpr cenv cgbuf endMark cloc v eenv =
         else
             NoShadowLocal, eenv
 
-    ComputeAndAddStorageForLocalValWithValReprInfo (cenv, g, cenv.intraAssemblyInfo, cenv.options.isInteractive, optShadowLocal) cloc v eenv
+    ComputeAndAddStorageForLocalValWithValReprInfo (cenv, eenv.intraAssemblyInfo, cenv.options.isInteractive, optShadowLocal) cloc v eenv
 
 //--------------------------------------------------------------------------
 // Generate stack save/restore and assertions - pulled into letrec by alloc*
@@ -9928,7 +10025,19 @@ and CreatePermissionSets cenv eenv (securityAttributes: Attrib list) =
 //--------------------------------------------------------------------------
 
 /// Generate a static class at the given cloc
-and GenTypeDefForCompLoc (cenv, eenv, mgbuf: AssemblyBuilder, cloc, hidden, attribs, initTrigger, eliminateIfEmpty, addAtEnd) =
+and GenTypeDefForCompLoc
+    (
+        cenv,
+        eenv,
+        mgbuf: AssemblyBuilder,
+        cloc,
+        hidden,
+        accessibility: Accessibility,
+        attribs,
+        initTrigger,
+        eliminateIfEmpty,
+        addAtEnd
+    ) =
     let g = cenv.g
     let tref = TypeRefForCompLoc cloc
 
@@ -9936,7 +10045,7 @@ and GenTypeDefForCompLoc (cenv, eenv, mgbuf: AssemblyBuilder, cloc, hidden, attr
         mkILSimpleClass
             g.ilg
             (tref.Name,
-             ComputeTypeAccess tref hidden,
+             ComputeTypeAccess tref hidden accessibility cenv.g.realsig,
              emptyILMethods,
              emptyILFields,
              emptyILTypeDefs,
@@ -9980,16 +10089,69 @@ and GenImplFileContents cenv cgbuf qname lazyInitInfo eenv mty def =
         let _eenvEnd = GenModuleOrNamespaceContents cenv cgbuf qname lazyInitInfo eenv def
         ())
 
+and CodeGenInitMethod cenv (cgbuf: CodeGenBuffer) eenv tref (codeGenInitFunc: CodeGenBuffer -> IlxGenEnv -> unit) m =
+
+    // Generate the declarations in the module and its initialization code
+    let _, body =
+        CodeGenMethod cenv cgbuf.mgbuf ([], eenv.staticInitializationName, eenv, 0, None, codeGenInitFunc, m)
+
+    if CheckCodeDoesSomething body.Code then
+        // We are here because the module we just grabbed has an interesting static initializer
+        let feefee, seqpt =
+            if body.Code.Instrs.Length > 0 then
+                match body.Code.Instrs[0] with
+                | I_seqpoint sp as i -> [ FeeFeeInstr cenv sp.Document ], [ i ]
+                | _ -> [], []
+            else
+                [], []
+
+        let ilDebugRange = GenPossibleILDebugRange cenv m
+
+        // Call global file initializer
+        match eenv.initClassFieldSpec with
+        | Some fs -> cgbuf.mgbuf.AddExplicitInitToCctor(tref, fs.Force(), ilDebugRange, eenv.imports, feefee, seqpt)
+        | None -> ()
+
+        // Add code to invoke envinner's class static initializer
+        let access = ComputeMemberAccess true taccessInternal eenv.realsig
+
+        let ilBody = MethodBody.IL(InterruptibleLazy.FromValue body)
+        let ilReturn = mkILReturn ILType.Void
+
+        let method =
+            (mkILNonGenericStaticMethod (eenv.staticInitializationName, access, [], ilReturn, ilBody))
+                .WithSpecialName
+
+        cgbuf.mgbuf.AddMethodDef(tref, method)
+        CountMethodDef()
+
+        let ty =
+            let td = cgbuf.mgbuf.FindNestedTypeDefBuilder(tref).ILTypeDef
+            let boxity = if td.IsStruct then ILBoxity.AsValue else ILBoxity.AsObject
+            mkILFormalNamedTy boxity tref td.GenericParams
+
+        let methodSpec =
+            mkILNonGenericStaticMethSpecInTy (ty, eenv.staticInitializationName, [], ILType.Void)
+
+        cgbuf.EmitInstr((pop 0), Push0, mkNormalCall (methodSpec))
+
 and GenModuleOrNamespaceContents cenv (cgbuf: CodeGenBuffer) qname lazyInitInfo eenv x =
     match x with
     | TMDefRec(_isRec, opens, tycons, mbinds, m) ->
         let eenvinner = AddDebugImportsToEnv cenv eenv opens
 
+        let dict = Some(Dictionary<Stamp, ILTypeRef>())
+
         for tc in tycons do
-            if tc.IsFSharpException then
-                GenExnDef cenv cgbuf.mgbuf eenvinner m tc
-            else
-                GenTypeDef cenv cgbuf.mgbuf lazyInitInfo eenvinner m tc
+            let optTref =
+                if tc.IsFSharpException then
+                    GenExnDef cenv cgbuf.mgbuf eenv m tc
+                else
+                    GenTypeDef cenv cgbuf.mgbuf lazyInitInfo eenv m tc
+
+            match optTref with
+            | Some tref -> dict.Value.Add(tc.Stamp, tref)
+            | None -> ()
 
         // Generate chunks of non-nested bindings together to allow recursive fixups.
         let mutable bindsRemaining = mbinds
@@ -9997,6 +10159,7 @@ and GenModuleOrNamespaceContents cenv (cgbuf: CodeGenBuffer) qname lazyInitInfo
         while not bindsRemaining.IsEmpty do
             match bindsRemaining with
             | ModuleOrNamespaceBinding.Binding _ :: _ ->
+
                 let recBinds =
                     bindsRemaining
                     |> List.takeWhile (function
@@ -10012,7 +10175,7 @@ and GenModuleOrNamespaceContents cenv (cgbuf: CodeGenBuffer) qname lazyInitInfo
                         | ModuleOrNamespaceBinding.Binding _ -> true
                         | _ -> false)
 
-                GenLetRecBindings cenv cgbuf eenv (recBinds, m)
+                GenLetRecBindings cenv cgbuf eenv (recBinds, m) dict
                 bindsRemaining <- otherBinds
             | (ModuleOrNamespaceBinding.Module _ as mbind) :: rest ->
                 GenModuleBinding cenv cgbuf qname lazyInitInfo eenvinner m mbind
@@ -10040,21 +10203,24 @@ and GenModuleOrNamespaceContents cenv (cgbuf: CodeGenBuffer) qname lazyInitInfo
 // Generate a module binding
 and GenModuleBinding cenv (cgbuf: CodeGenBuffer) (qname: QualifiedNameOfFile) lazyInitInfo eenv m x =
     match x with
-    | ModuleOrNamespaceBinding.Binding bind -> GenLetRecBindings cenv cgbuf eenv ([ bind ], m)
+    | ModuleOrNamespaceBinding.Binding bind -> GenLetRecBindings cenv cgbuf eenv ([ bind ], m) None
+
+    | ModuleOrNamespaceBinding.Module(mspec, mdef) when mspec.IsNamespace ->
+        // Generate the declarations in the namespace and its initialization code
+        GenModuleOrNamespaceContents cenv cgbuf qname lazyInitInfo eenv mdef |> ignore
 
     | ModuleOrNamespaceBinding.Module(mspec, mdef) ->
+
+        // Evaluate bindings for module
         let hidden = IsHiddenTycon eenv.sigToImplRemapInfo mspec
 
         let eenvinner =
-            if mspec.IsNamespace then
-                eenv
-            else
-                { eenv with
-                    cloc = CompLocForFixedModule cenv.options.fragName qname.Text mspec
-                    initLocals =
-                        eenv.initLocals
-                        && not (HasFSharpAttribute cenv.g cenv.g.attrib_SkipLocalsInitAttribute mspec.Attribs)
-                }
+            { eenv with
+                cloc = CompLocForFixedModule cenv.options.fragName qname.Text mspec
+                initLocals =
+                    eenv.initLocals
+                    && not (HasFSharpAttribute cenv.g cenv.g.attrib_SkipLocalsInitAttribute mspec.Attribs)
+            }
 
         // Create the class to hold the contents of this module. No class needed if
         // we're compiling it as a namespace.
@@ -10063,44 +10229,46 @@ and GenModuleBinding cenv (cgbuf: CodeGenBuffer) (qname: QualifiedNameOfFile) la
         // However mutable static fields go into the class for the module itself.
         // So this static class ends up with a .cctor if it has mutable fields.
         //
-        if not mspec.IsNamespace then
-            // The use of ILTypeInit.OnAny prevents the execution of the cctor before the
-            // "main" method in the case where the "main" method is implicit.
-            let staticClassTrigger = (* if eenv.isFinalFile then *)
-                ILTypeInit.OnAny (* else ILTypeInit.BeforeField *)
-
-            GenTypeDefForCompLoc(
-                cenv,
-                eenvinner,
-                cgbuf.mgbuf,
-                eenvinner.cloc,
-                hidden,
-                mspec.Attribs,
-                staticClassTrigger,
-                false (* atEnd= *) ,
-                true
-            )
 
-        // Generate the declarations in the module and its initialization code
-        let _envAtEnd =
-            GenModuleOrNamespaceContents cenv cgbuf qname lazyInitInfo eenvinner mdef
+        // The use of ILTypeInit.OnAny prevents the execution of the cctor before the
+        // "main" method in the case where the "main" method is implicit.
+        let staticClassTrigger = ILTypeInit.OnAny
+
+        GenTypeDefForCompLoc(
+            cenv,
+            eenvinner,
+            cgbuf.mgbuf,
+            eenvinner.cloc,
+            hidden,
+            mspec.Accessibility,
+            mspec.Attribs,
+            staticClassTrigger,
+            false (* atEnd= *) ,
+            true
+        )
 
-        // If the module has a .cctor for some mutable fields, we need to ensure that when
-        // those fields are "touched" the InitClass .cctor is forced. The InitClass .cctor will
-        // then fill in the value of the mutable fields.
-        if
-            not mspec.IsNamespace
-            && (cgbuf.mgbuf.GetCurrentFields(TypeRefForCompLoc eenvinner.cloc)
-                |> Seq.isEmpty
-                |> not)
-        then
-            GenForceWholeFileInitializationAsPartOfCCtor
+        let tref = TypeRefForCompLoc eenvinner.cloc
+
+        if eenv.realsig then
+            CodeGenInitMethod
                 cenv
-                cgbuf.mgbuf
-                lazyInitInfo
-                (TypeRefForCompLoc eenvinner.cloc)
-                eenv.imports
-                mspec.Range
+                cgbuf
+                eenvinner
+                tref
+                (fun cgbuf eenv ->
+                    GenModuleOrNamespaceContents cenv cgbuf qname lazyInitInfo eenv mdef |> ignore
+                    CG.EmitInstr cgbuf (pop 0) Push0 I_ret //)
+                )
+                m
+        else
+            GenModuleOrNamespaceContents cenv cgbuf qname lazyInitInfo eenvinner mdef
+            |> ignore
+
+            // If the module has a .cctor for some mutable fields, we need to ensure that when
+            // those fields are "touched" the InitClass .cctor is forced. The InitClass .cctor will
+            // then fill in the value of the mutable fields.
+            if not (cgbuf.mgbuf.GetCurrentFields(tref) |> Seq.isEmpty) then
+                GenForceWholeFileInitializationAsPartOfCCtor cenv cgbuf.mgbuf lazyInitInfo tref eenv.imports mspec.Range
 
 /// Generate the namespace fragments in a single file
 and GenImplFile cenv (mgbuf: AssemblyBuilder) mainInfoOpt eenv (implFile: CheckedImplFileAfterOptimization) =
@@ -10108,7 +10276,6 @@ and GenImplFile cenv (mgbuf: AssemblyBuilder) mainInfoOpt eenv (implFile: Checke
         implFile.ImplFile
 
     let optimizeDuringCodeGen = implFile.OptimizeDuringCodeGen
-    let g = cenv.g
     let m = qname.Range
 
     // Generate all the anonymous record types mentioned anywhere in this module
@@ -10130,21 +10297,38 @@ and GenImplFile cenv (mgbuf: AssemblyBuilder) mainInfoOpt eenv (implFile: Checke
 
     let initClassCompLoc = CompLocForInitClass eenv.cloc
     let initClassTy = mkILTyForCompLoc initClassCompLoc
+    let initClassTrigger = ILTypeInit.OnAny
+
+    let initClassFieldSpec =
+        lazy
+            let ilFieldDef =
+                mkILStaticField (
+                    eenv.initFieldName,
+                    cenv.g.ilg.typ_Int32,
+                    None,
+                    None,
+                    ComputeMemberAccess true taccessInternal cenv.g.realsig
+                )
+                |> cenv.g.AddFieldNeverAttributes
+                |> cenv.g.AddFieldGeneratedAttributes
 
-    let initClassTrigger = (* if isFinalFile then *)
-        ILTypeInit.OnAny (* else ILTypeInit.BeforeField *)
+            CountStaticFieldDef()
+            mgbuf.AddFieldDef(initClassTy.TypeRef, ilFieldDef)
+            mkILFieldSpecInTy (initClassTy, eenv.initFieldName, cenv.g.ilg.typ_Int32)
 
     let eenv =
         { eenv with
             cloc = initClassCompLoc
+            initClassCompLoc = Some initClassCompLoc
             isFinalFile = isFinalFile
             someTypeInThisAssembly = initClassTy
+            initClassFieldSpec = Some initClassFieldSpec
         }
 
     // Create the class to hold the initialization code and static fields for this file.
     //     internal static class $<StartupCode...> {}
     // Put it at the end since that gives an approximation of dependency order (to aid FSI.EXE's code generator - see FSharp 1.0 5548)
-    GenTypeDefForCompLoc(cenv, eenv, mgbuf, initClassCompLoc, useHiddenInitCode, [], initClassTrigger, false, true)
+    GenTypeDefForCompLoc(cenv, eenv, mgbuf, initClassCompLoc, useHiddenInitCode, taccessInternal, [], initClassTrigger, false, true)
 
     // lazyInitInfo is an accumulator of functions which add the forced initialization of the storage module to
     //    - mutable fields in public modules
@@ -10259,30 +10443,24 @@ and GenImplFile cenv (mgbuf: AssemblyBuilder) mainInfoOpt eenv (implFile: Checke
         // Create the field to act as the target for the forced initialization.
         // Why do this for the final file?
         // There is no need to do this for a final file with an implicit entry point. For an explicit entry point in lazyInitInfo.
-        let initFieldName = CompilerGeneratedName "init"
-
-        let ilFieldDef =
-            mkILStaticField (initFieldName, g.ilg.typ_Int32, None, None, ComputeMemberAccess true)
-            |> g.AddFieldNeverAttributes
-            |> g.AddFieldGeneratedAttributes
-
-        let fspec = mkILFieldSpecInTy (initClassTy, initFieldName, cenv.g.ilg.typ_Int32)
-        CountStaticFieldDef()
-        mgbuf.AddFieldDef(initClassTy.TypeRef, ilFieldDef)
+        initClassFieldSpec.Force() |> ignore
 
         // Run the imperative (yuck!) actions that force the generation
         // of references to the cctor for nested modules etc.
-        lazyInitInfo |> Seq.iter (fun f -> f fspec feefee seqpt)
+        match eenv.initClassFieldSpec with
+        | Some fspec ->
+            lazyInitInfo |> Seq.iter (fun f -> f (fspec.Force()) feefee seqpt)
 
-        if isScript && not isFinalFile then
-            mgbuf.AddScriptInitFieldSpec(fspec, m)
+            if isScript && not isFinalFile then
+                mgbuf.AddScriptInitFieldSpec(fspec.Force(), m)
+        | None -> ()
 
     // Compute the ilxgenEnv after the generation of the module, i.e. the residue need to generate anything that
     // uses the constructs exported from this module.
     // We add the module type all over again. Note no shadow locals for static fields needed here since they are only relevant to the main/.cctor
     let eenvafter =
         let allocVal =
-            ComputeAndAddStorageForLocalValWithValReprInfo(cenv, g, cenv.intraAssemblyInfo, cenv.options.isInteractive, NoShadowLocal)
+            ComputeAndAddStorageForLocalValWithValReprInfo(cenv, eenv.intraAssemblyInfo, cenv.options.isInteractive, NoShadowLocal)
 
         AddBindingsForLocalModuleOrNamespaceType allocVal clocCcu eenv signature
 
@@ -10528,12 +10706,12 @@ and GenPrintingMethod cenv eenv methName ilThisTy m =
             | _ -> ()
     ]
 
-and GenTypeDef cenv mgbuf lazyInitInfo eenv m (tycon: Tycon) =
+and GenTypeDef cenv mgbuf lazyInitInfo eenv m (tycon: Tycon) : ILTypeRef option =
     let g = cenv.g
     let tcref = mkLocalTyconRef tycon
 
     if tycon.IsTypeAbbrev then
-        ()
+        None
     else
         match tycon.TypeReprInfo with
 #if !NO_TYPEPROVIDERS
@@ -10543,7 +10721,7 @@ and GenTypeDef cenv mgbuf lazyInitInfo eenv m (tycon: Tycon) =
         | TNoRepr
         | TAsmRepr _
         | TILObjectRepr _
-        | TMeasureableRepr _ -> ()
+        | TMeasureableRepr _ -> None
         | TFSharpTyconRepr _ ->
             let eenvinner = EnvForTycon tycon eenv
             let thisTy = generalizedTyconRef g tcref
@@ -10559,8 +10737,17 @@ and GenTypeDef cenv mgbuf lazyInitInfo eenv m (tycon: Tycon) =
             let ilTypeName = tref.Name
 
             let hidden = IsHiddenTycon eenv.sigToImplRemapInfo tycon
+
             let hiddenRepr = hidden || IsHiddenTyconRepr eenv.sigToImplRemapInfo tycon
-            let access = ComputeTypeAccess tref hidden
+
+            let tyconAccess =
+                let tycon =
+                    if eenv.realsig then
+                        DoRemapTycon eenv.sigToImplRemapInfo tycon
+                    else
+                        tycon
+
+                ComputeTypeAccess tref hidden tycon.Accessibility cenv.g.realsig
 
             // The implicit augmentation doesn't actually create CompareTo(object) or Object.Equals
             // So we do it here.
@@ -10662,7 +10849,7 @@ and GenTypeDef cenv mgbuf lazyInitInfo eenv m (tycon: Tycon) =
 
             let tyconRepr = tycon.TypeReprInfo
 
-            let reprAccess = ComputeMemberAccess hiddenRepr
+            let reprAccess = ComputeMemberAccess hiddenRepr taccessPublic cenv.g.realsig
 
             // DebugDisplayAttribute gets copied to the subtypes generated as part of DU compilation
             let debugDisplayAttrs, normalAttrs =
@@ -10828,7 +11015,7 @@ and GenTypeDef cenv mgbuf lazyInitInfo eenv m (tycon: Tycon) =
                                 [ g.CompilerGeneratedAttribute; g.DebuggerBrowsableNeverAttribute ]
                             | _ -> [] // don't hide fields in classes in debug display
 
-                        let access = ComputeMemberAccess isFieldHidden
+                        let access = ComputeMemberAccess isFieldHidden taccessPublic cenv.g.realsig
 
                         let literalValue = Option.map (GenFieldInit m) fspec.LiteralValue
 
@@ -10898,7 +11085,9 @@ and GenTypeDef cenv mgbuf lazyInitInfo eenv m (tycon: Tycon) =
                         if not useGenuineField then
                             let ilPropName = fspec.LogicalName
                             let ilMethName = "get_" + ilPropName
-                            let access = ComputeMemberAccess isPropHidden
+
+                            let access = ComputeMemberAccess isPropHidden taccessPublic cenv.g.realsig
+
                             let isStruct = isStructTyconRef tcref
 
                             let attrs =
@@ -10921,7 +11110,8 @@ and GenTypeDef cenv mgbuf lazyInitInfo eenv m (tycon: Tycon) =
                             let ilMethName = "set_" + ilPropName
                             let ilParams = [ mkILParamNamed ("value", ilPropType) ]
                             let ilReturn = mkILReturn ILType.Void
-                            let iLAccess = ComputeMemberAccess isPropHidden
+
+                            let iLAccess = ComputeMemberAccess isPropHidden taccessPublic cenv.g.realsig
 
                             let ilMethodDef =
                                 if isStatic then
@@ -11128,7 +11318,7 @@ and GenTypeDef cenv mgbuf lazyInitInfo eenv m (tycon: Tycon) =
 
                 match tycon.TypeReprInfo with
                 | TILObjectRepr _ ->
-                    let tdef = tycon.ILTyconRawMetadata.WithAccess access
+                    let tdef = tycon.ILTyconRawMetadata.WithAccess tyconAccess
 
                     let tdef =
                         tdef.With(customAttrs = mkILCustomAttrs ilCustomAttrs, genericParams = ilGenParams)
@@ -11170,7 +11360,7 @@ and GenTypeDef cenv mgbuf lazyInitInfo eenv m (tycon: Tycon) =
                     let tdef =
                         mkILGenericClass (
                             ilTypeName,
-                            access,
+                            tyconAccess,
                             ilGenParams,
                             ilBaseTy,
                             ilIntfTys,
@@ -11369,7 +11559,7 @@ and GenTypeDef cenv mgbuf lazyInitInfo eenv m (tycon: Tycon) =
                             .WithSerializable(isSerializable)
                             .WithSealed(true)
                             .WithEncoding(ILDefaultPInvokeEncoding.Auto)
-                            .WithAccess(access)
+                            .WithAccess(tyconAccess)
                             // If there are static fields in the union, use the same kind of trigger as
                             // for class types
                             .WithInitSemantics(
@@ -11428,26 +11618,39 @@ and GenTypeDef cenv mgbuf lazyInitInfo eenv m (tycon: Tycon) =
             // In this case, the .cctor for this type must force the .cctor of the backing static class for the file.
             if
                 tycon.TyparsNoRange.IsEmpty
+                && not (eenv.realsig)
                 && tycon.MembersOfFSharpTyconSorted
                    |> List.exists (fun vref -> vref.Deref.IsClassConstructor)
             then
                 GenForceWholeFileInitializationAsPartOfCCtor cenv mgbuf lazyInitInfo tref eenv.imports m
 
+            Some tref
+
 /// Generate the type for an F# exception declaration.
-and GenExnDef cenv mgbuf eenv m (exnc: Tycon) =
+and GenExnDef cenv mgbuf eenv m (exnc: Tycon) : ILTypeRef option =
     let g = cenv.g
     let exncref = mkLocalEntityRef exnc
 
     match exnc.ExceptionInfo with
     | TExnAbbrevRepr _
     | TExnAsmRepr _
-    | TExnNone -> ()
+    | TExnNone -> None
     | TExnFresh _ ->
         let ilThisTy = GenExnType cenv m eenv.tyenv exncref
         let tref = ilThisTy.TypeRef
         let isHidden = IsHiddenTycon eenv.sigToImplRemapInfo exnc
-        let access = ComputeTypeAccess tref isHidden
-        let reprAccess = ComputeMemberAccess isHidden
+
+        let access =
+            let tycon =
+                if eenv.realsig then
+                    DoRemapTycon eenv.sigToImplRemapInfo exnc
+                else
+                    exnc
+
+            ComputeTypeAccess tref isHidden tycon.Accessibility cenv.g.realsig
+
+        let reprAccess = ComputeMemberAccess isHidden taccessPublic cenv.g.realsig
+
         let fspecs = exnc.TrueInstanceFieldsAsList
 
         let ilMethodDefsForProperties, ilFieldDefs, ilPropertyDefs, fieldNamesAndTypes =
@@ -11579,6 +11782,7 @@ and GenExnDef cenv mgbuf eenv m (exnc: Tycon) =
 
         let tdef = tdef.WithSerializable(true)
         mgbuf.AddTypeDef(tref, tdef, false, false, None)
+        Some tref
 
 let CodegenAssembly cenv eenv mgbuf implFiles =
     match List.tryFrontAndBack implFiles with
@@ -11631,11 +11835,12 @@ let CodegenAssembly cenv eenv mgbuf implFiles =
 //-------------------------------------------------------------------------
 
 let GetEmptyIlxGenEnv (g: TcGlobals) ccu =
-    let thisCompLoc = CompLocForCcu ccu
-
     {
         tyenv = TypeReprEnv.Empty
-        cloc = thisCompLoc
+        cloc = CompLocForCcu ccu
+        initClassCompLoc = None
+        initFieldName = CompilerGeneratedName "init"
+        staticInitializationName = CompilerGeneratedName "staticInitialization"
         exitSequel = Return
         valsInScope = ValMap<_>.Empty
         witnessesInScope = EmptyTraitWitnessInfoHashMap g
@@ -11652,6 +11857,9 @@ let GetEmptyIlxGenEnv (g: TcGlobals) ccu =
         imports = None
         delayCodeGen = true
         delayedFileGenReverse = []
+        intraAssemblyInfo = IlxGenIntraAssemblyInfo.Create()
+        realsig = g.realsig
+        initClassFieldSpec = None
     }
 
 type IlxGenResults =
@@ -11722,6 +11930,7 @@ let GenerateCode (cenv, anonTypeTable, eenv, CheckedAssemblyAfterOptimization im
         mgbuf,
         CompLocForPrivateImplementationDetails eenv.cloc,
         useHiddenInitCode,
+        taccessInternal,
         [],
         ILTypeInit.BeforeField,
         true (* atEnd= *) ,
@@ -11879,26 +12088,21 @@ let ClearGeneratedValue (ctxt: ExecutionContext) eenv (v: Val) =
         ()
 
 /// The published API from the ILX code generator
-type IlxAssemblyGenerator(amap: ImportMap, tcGlobals: TcGlobals, tcVal: ConstraintSolver.TcValF, ccu: CcuThunk) =
+type IlxAssemblyGenerator(amap: ImportMap, g: TcGlobals, tcVal: ConstraintSolver.TcValF, ccu: CcuThunk) =
 
     // The incremental state held by the ILX code generator
-    let mutable ilxGenEnv = GetEmptyIlxGenEnv tcGlobals ccu
+    let mutable ilxGenEnv = GetEmptyIlxGenEnv g ccu
     let anonTypeTable = AnonTypeGenerationTable()
 
-    let intraAssemblyInfo =
-        {
-            StaticFieldInfo = ConcurrentDictionary<_, _>(HashIdentity.Structural)
-        }
-
     let cenv =
         {
-            g = tcGlobals
+            g = g
             ilxPubCloEnv =
                 EraseClosures.newIlxPubCloEnv (
-                    tcGlobals.ilg,
-                    tcGlobals.AddMethodGeneratedAttributes,
-                    tcGlobals.AddFieldGeneratedAttributes,
-                    tcGlobals.AddFieldNeverAttributes
+                    g.ilg,
+                    g.AddMethodGeneratedAttributes,
+                    g.AddFieldGeneratedAttributes,
+                    g.AddFieldNeverAttributes
                 )
             tcVal = tcVal
             viewCcu = ccu
@@ -11906,7 +12110,6 @@ type IlxAssemblyGenerator(amap: ImportMap, tcGlobals: TcGlobals, tcVal: Constrai
             namedDebugPointsForInlinedCode = Map.empty
             amap = amap
             casApplied = ConcurrentDictionary<Stamp, bool>()
-            intraAssemblyInfo = intraAssemblyInfo
             optionsOpt = None
             optimizeDuringCodeGen = (fun _flag expr -> expr)
             stackGuard = getEmptyStackGuard ()
@@ -11915,22 +12118,12 @@ type IlxAssemblyGenerator(amap: ImportMap, tcGlobals: TcGlobals, tcVal: Constrai
 
     /// Register a set of referenced assemblies with the ILX code generator
     member _.AddExternalCcus ccus =
-        ilxGenEnv <- AddExternalCcusToIlxGenEnv cenv tcGlobals ilxGenEnv ccus
+        ilxGenEnv <- AddExternalCcusToIlxGenEnv cenv ilxGenEnv ccus
 
     /// Register a fragment of the current assembly with the ILX code generator. If 'isIncrementalFragment' is true then the input
     /// is assumed to be a fragment 'typed' into FSI.EXE, otherwise the input is assumed to be the result of a '#load'
     member _.AddIncrementalLocalAssemblyFragment(isIncrementalFragment, fragName, typedImplFiles) =
-        ilxGenEnv <-
-            AddIncrementalLocalAssemblyFragmentToIlxGenEnv(
-                cenv,
-                isIncrementalFragment,
-                tcGlobals,
-                ccu,
-                fragName,
-                intraAssemblyInfo,
-                ilxGenEnv,
-                typedImplFiles
-            )
+        ilxGenEnv <- AddIncrementalLocalAssemblyFragmentToIlxGenEnv(cenv, isIncrementalFragment, ccu, fragName, ilxGenEnv, typedImplFiles)
 
     /// Generate ILX code for an assembly fragment
     member _.GenerateCode(codeGenOpts, typedAssembly: CheckedAssemblyAfterOptimization, assemAttribs, moduleAttribs) =
diff --git a/src/Compiler/Driver/CompilerConfig.fs b/src/Compiler/Driver/CompilerConfig.fs
index 32298c0cf05..54a69b05f8c 100644
--- a/src/Compiler/Driver/CompilerConfig.fs
+++ b/src/Compiler/Driver/CompilerConfig.fs
@@ -610,6 +610,8 @@ type TcConfigBuilder =
         mutable typeCheckingConfig: TypeCheckingConfig
 
         mutable dumpSignatureData: bool
+
+        mutable realsig: bool
     }
 
     // Directories to start probing in
@@ -817,6 +819,7 @@ type TcConfigBuilder =
                     DumpGraph = false
                 }
             dumpSignatureData = false
+            realsig = false
             strictIndentation = None
         }
 
@@ -1360,6 +1363,7 @@ type TcConfig private (data: TcConfigBuilder, validate: bool) =
     member _.captureIdentifiersWhenParsing = data.captureIdentifiersWhenParsing
     member _.typeCheckingConfig = data.typeCheckingConfig
     member _.dumpSignatureData = data.dumpSignatureData
+    member _.realsig = data.realsig
 
     static member Create(builder, validate) =
         use _ = UseBuildPhase BuildPhase.Parameter
diff --git a/src/Compiler/Driver/CompilerConfig.fsi b/src/Compiler/Driver/CompilerConfig.fsi
index f59950f9e28..f5360fbb972 100644
--- a/src/Compiler/Driver/CompilerConfig.fsi
+++ b/src/Compiler/Driver/CompilerConfig.fsi
@@ -519,6 +519,8 @@ type TcConfigBuilder =
         mutable typeCheckingConfig: TypeCheckingConfig
 
         mutable dumpSignatureData: bool
+
+        mutable realsig: bool
     }
 
     static member CreateNew:
@@ -894,6 +896,8 @@ type TcConfig =
 
     member dumpSignatureData: bool
 
+    member realsig: bool
+
 /// Represents a computation to return a TcConfig. Normally this is just a constant immutable TcConfig,
 /// but for F# Interactive it may be based on an underlying mutable TcConfigBuilder.
 [<Sealed>]
diff --git a/src/Compiler/Driver/CompilerImports.fs b/src/Compiler/Driver/CompilerImports.fs
index d8d9ccd9866..090e5597440 100644
--- a/src/Compiler/Driver/CompilerImports.fs
+++ b/src/Compiler/Driver/CompilerImports.fs
@@ -1667,6 +1667,7 @@ and [<Sealed>] TcImports
                 let cpath =
                     CompPath(
                         ILScopeRef.Local,
+                        SyntaxAccess.Unknown,
                         injectedNamespace
                         |> List.rev
                         |> List.map (fun n -> (n, ModuleOrNamespaceKind.Namespace true))
@@ -2522,7 +2523,8 @@ and [<Sealed>] TcImports
                     tcConfig.emitDebugInfoInQuotations,
                     tcConfig.noDebugAttributes,
                     tcConfig.pathMap,
-                    tcConfig.langVersion
+                    tcConfig.langVersion,
+                    tcConfig.realsig
                 )
 
 #if DEBUG
diff --git a/src/Compiler/Driver/CompilerOptions.fs b/src/Compiler/Driver/CompilerOptions.fs
index d1618dd19d6..e742a20e139 100644
--- a/src/Compiler/Driver/CompilerOptions.fs
+++ b/src/Compiler/Driver/CompilerOptions.fs
@@ -568,6 +568,9 @@ let SetTailcallSwitch (tcConfigB: TcConfigBuilder) switch =
 let SetDeterministicSwitch (tcConfigB: TcConfigBuilder) switch =
     tcConfigB.deterministic <- (switch = OptionSwitch.On)
 
+let SetRealsig (tcConfigB: TcConfigBuilder) switch =
+    tcConfigB.realsig <- (switch = OptionSwitch.On)
+
 let SetReferenceAssemblyOnlySwitch (tcConfigB: TcConfigBuilder) switch =
     match tcConfigB.emitMetadataAssembly with
     | MetadataAssemblyGeneration.None when (not tcConfigB.standalone) && tcConfigB.extraStaticLinkRoots.IsEmpty ->
@@ -1026,6 +1029,8 @@ let codeGenerationFlags isFsi (tcConfigB: TcConfigBuilder) =
                 Some(FSComp.SR.optsDeterministic ())
             )
 
+            CompilerOption("realsig", tagNone, OptionSwitch(SetRealsig tcConfigB), None, Some(FSComp.SR.optsRealsig ()))
+
             CompilerOption("pathmap", tagPathMap, OptionStringList(AddPathMapping tcConfigB), None, Some(FSComp.SR.optsPathMap ()))
 
             CompilerOption(
diff --git a/src/Compiler/FSComp.txt b/src/Compiler/FSComp.txt
index a1086629fbe..52a5a184823 100644
--- a/src/Compiler/FSComp.txt
+++ b/src/Compiler/FSComp.txt
@@ -879,6 +879,7 @@ optsDebug,"Specify debugging type: full, portable, embedded, pdbonly. ('%s' is t
 optsOptimize,"Enable optimizations (Short form: -O)"
 optsTailcalls,"Enable or disable tailcalls"
 optsDeterministic,"Produce a deterministic assembly (including module version GUID and timestamp)"
+optsRealsig,"Generate assembly with IL visibility that matches the source code visibility"
 optsRefOnly,"Produce a reference assembly, instead of a full assembly, as the primary output"
 optsRefOut,"Produce a reference assembly with the specified file path."
 optsPathMap,"Maps physical paths to source path names output by the compiler"
@@ -993,7 +994,6 @@ lexhlpIdentifierReserved,"The identifier '%s' is reserved for future use by F#"
 1112,impImportedAssemblyUsesNotPublicType,"An imported assembly uses the type '%s' but that type is not public"
 1113,optValueMarkedInlineButIncomplete,"The value '%s' was marked inline but its implementation makes use of an internal or private function which is not sufficiently accessible"
 1114,optValueMarkedInlineButWasNotBoundInTheOptEnv,"The value '%s' was marked inline but was not bound in the optimization environment"
-1115,optLocalValueNotFoundDuringOptimization,"Local value %s not found during optimization"
 1116,optValueMarkedInlineHasUnexpectedValue,"A value marked as 'inline' has an unexpected value"
 1117,optValueMarkedInlineCouldNotBeInlined,"A value marked as 'inline' could not be inlined"
 1118,optFailedToInlineValue,"Failed to inline the value '%s' marked 'inline', perhaps because a recursive value was marked 'inline'"
@@ -1595,6 +1595,7 @@ featureChkTailCallAttrOnNonRec,"Raises warnings if the 'TailCall' attribute is u
 featureUnionIsPropertiesVisible,"Union case test properties"
 featureBooleanReturningAndReturnTypeDirectedPartialActivePattern,"Boolean-returning and return-type-directed partial active patterns"
 featureEnforceAttributeTargetsOnFunctions,"Enforce AttributeTargets on functions"
+featureEnforceAttributeTargetsUnionCaseDeclarations,"Enforce AttributeTargets on union case declarations"
 featureLowerInterpolatedStringToConcat,"Optimizes interpolated strings in certain cases, by lowering to concatenation"
 3354,tcNotAFunctionButIndexerNamedIndexingNotYetEnabled,"This value supports indexing, e.g. '%s.[index]'. The syntax '%s[index]' requires /langversion:preview. See https://aka.ms/fsharp-index-notation."
 3354,tcNotAFunctionButIndexerIndexingNotYetEnabled,"This expression supports indexing, e.g. 'expr.[index]'. The syntax 'expr[index]' requires /langversion:preview. See https://aka.ms/fsharp-index-notation."
diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj
index 6a52de46022..e1fe24ea421 100644
--- a/src/Compiler/FSharp.Compiler.Service.fsproj
+++ b/src/Compiler/FSharp.Compiler.Service.fsproj
@@ -21,7 +21,6 @@
     <OtherFlags>$(OtherFlags) --warnon:3218</OtherFlags>
     <!-- 3390: xmlDocBadlyFormed -->
     <OtherFlags>$(OtherFlags) --warnon:3390</OtherFlags>
-	<!--<OtherFlags>$(OtherFlags) - - allsigs</OtherFlags>-->
     <Tailcalls>true</Tailcalls> <!-- .tail annotations always emitted for this binary, even in debug mode -->
     <FsYaccOutputFolder>$(IntermediateOutputPath)$(TargetFramework)\</FsYaccOutputFolder>
     <FsLexOutputFolder>$(IntermediateOutputPath)$(TargetFramework)\</FsLexOutputFolder>
diff --git a/src/Compiler/Facilities/LanguageFeatures.fs b/src/Compiler/Facilities/LanguageFeatures.fs
index 6e2d91bc6cd..dd7133224e8 100644
--- a/src/Compiler/Facilities/LanguageFeatures.fs
+++ b/src/Compiler/Facilities/LanguageFeatures.fs
@@ -86,6 +86,7 @@ type LanguageFeature =
     | WarningWhenTailCallAttrOnNonRec
     | BooleanReturningAndReturnTypeDirectedPartialActivePattern
     | EnforceAttributeTargetsOnFunctions
+    | EnforceAttributeTargetsUnionCaseDeclarations
     | LowerInterpolatedStringToConcat
 
 /// LanguageVersion management
@@ -200,6 +201,7 @@ type LanguageVersion(versionText) =
                 LanguageFeature.UnionIsPropertiesVisible, previewVersion
                 LanguageFeature.BooleanReturningAndReturnTypeDirectedPartialActivePattern, previewVersion
                 LanguageFeature.EnforceAttributeTargetsOnFunctions, previewVersion
+                LanguageFeature.EnforceAttributeTargetsUnionCaseDeclarations, previewVersion
                 LanguageFeature.LowerInterpolatedStringToConcat, previewVersion
             ]
 
@@ -345,6 +347,7 @@ type LanguageVersion(versionText) =
         | LanguageFeature.BooleanReturningAndReturnTypeDirectedPartialActivePattern ->
             FSComp.SR.featureBooleanReturningAndReturnTypeDirectedPartialActivePattern ()
         | LanguageFeature.EnforceAttributeTargetsOnFunctions -> FSComp.SR.featureEnforceAttributeTargetsOnFunctions ()
+        | LanguageFeature.EnforceAttributeTargetsUnionCaseDeclarations -> FSComp.SR.featureEnforceAttributeTargetsUnionCaseDeclarations ()
         | LanguageFeature.LowerInterpolatedStringToConcat -> FSComp.SR.featureLowerInterpolatedStringToConcat ()
 
     /// Get a version string associated with the given feature.
diff --git a/src/Compiler/Facilities/LanguageFeatures.fsi b/src/Compiler/Facilities/LanguageFeatures.fsi
index 4888479d867..5be15a88284 100644
--- a/src/Compiler/Facilities/LanguageFeatures.fsi
+++ b/src/Compiler/Facilities/LanguageFeatures.fsi
@@ -77,6 +77,7 @@ type LanguageFeature =
     | WarningWhenTailCallAttrOnNonRec
     | BooleanReturningAndReturnTypeDirectedPartialActivePattern
     | EnforceAttributeTargetsOnFunctions
+    | EnforceAttributeTargetsUnionCaseDeclarations
     | LowerInterpolatedStringToConcat
 
 /// LanguageVersion management
diff --git a/src/Compiler/Interactive/fsi.fs b/src/Compiler/Interactive/fsi.fs
index e5ff5b6c754..a6ea4f1867e 100644
--- a/src/Compiler/Interactive/fsi.fs
+++ b/src/Compiler/Interactive/fsi.fs
@@ -1606,7 +1606,10 @@ let rec ConvReflectionTypeToILType (reflectionTy: Type) =
 
 let internal mkBoundValueTypedImpl tcGlobals m moduleName name ty =
     let vis = Accessibility.TAccess([])
-    let compPath = (CompilationPath.CompPath(ILScopeRef.Local, []))
+
+    let compPath =
+        (CompilationPath.CompPath(ILScopeRef.Local, SyntaxAccess.Unknown, []))
+
     let mutable mty = Unchecked.defaultof<_>
 
     let entity =
diff --git a/src/Compiler/Optimize/InnerLambdasToTopLevelFuncs.fs b/src/Compiler/Optimize/InnerLambdasToTopLevelFuncs.fs
index 37b3f26c429..291e24fe6e9 100644
--- a/src/Compiler/Optimize/InnerLambdasToTopLevelFuncs.fs
+++ b/src/Compiler/Optimize/InnerLambdasToTopLevelFuncs.fs
@@ -129,10 +129,10 @@ let mkLocalNameTypeArity compgen m name ty valReprInfo =
 //-------------------------------------------------------------------------
 
 //-------------------------------------------------------------------------
-// pass1: GetValsBoundUnderMustInline (see comment further below)
+// pass1: GetValsBoundUnderShouldInline (see comment further below)
 //-------------------------------------------------------------------------
 
-let GetValsBoundUnderMustInline xinfo =
+let GetValsBoundUnderShouldInline xinfo =
     let accRejectFrom (v: Val) repr rejectS =
       if v.InlineInfo = ValInline.Always then
         Zset.union (GetValsBoundInExpr repr) rejectS
@@ -194,8 +194,14 @@ module Pass1_DetermineTLRAndArities =
             let nFormals = vss.Length
             let nMaxApplied = GetMaxNumArgsAtUses xinfo f
             let arity = Operators.min nFormals nMaxApplied
-            if atTopLevel || arity<>0 || not (isNil tps) then Some (f, arity)
-            else None
+            if atTopLevel then
+                Some (f, arity)
+            elif g.realsig then
+                None
+            else if arity<>0 || not (isNil tps) then
+                Some (f, arity)
+            else
+                None
 
     /// Check if f involves any value recursion (so can skip those).
     /// ValRec considered: recursive && some f in mutual binding is not bound to a lambda
@@ -213,21 +219,21 @@ module Pass1_DetermineTLRAndArities =
        let xinfo = GetUsageInfoOfImplFile g expr
        let fArities = Zmap.chooseL (SelectTLRVals g xinfo) xinfo.Defns
        let fArities = List.filter (fst >> IsValueRecursionFree xinfo) fArities
-       // Do not TLR v if it is bound under a mustinline defn
+       // Do not TLR v if it is bound under a shouldinline defn
        // There is simply no point - the original value will be duplicated and TLR'd anyway
-       let rejectS = GetValsBoundUnderMustInline xinfo
+       let rejectS = GetValsBoundUnderShouldInline xinfo
        let fArities = List.filter (fun (v, _) -> not (Zset.contains v rejectS)) fArities
        (*-*)
        let tlrS = Zset.ofList valOrder (List.map fst fArities)
-       let topValS = xinfo.TopLevelBindings                     (* genuinely top level *)
-       let topValS = Zset.filter (IsMandatoryNonTopLevel g >> not) topValS     (* restrict *)
-       (* REPORT MISSED CASES *)
+       let topValS = xinfo.TopLevelBindings                                 (* genuinely top level *)
+       let topValS = Zset.filter (IsMandatoryNonTopLevel g >> not) topValS  (* restrict *)
 #if DEBUG
+       (* REPORT MISSED CASES *)
        if verboseTLR then
            let missed = Zset.diff  xinfo.TopLevelBindings tlrS
            missed |> Zset.iter (fun v -> dprintf "TopLevel but not TLR = %s\n" v.LogicalName)
-#endif
        (* REPORT OVER *)
+#endif
        let arityM = Zmap.ofList valOrder fArities
 #if DEBUG
        if verboseTLR then DumpArity arityM
@@ -885,24 +891,24 @@ module Pass4_RewriteAssembly =
     /// Any TLR repr bindings under lambdas can be filtered out (and collected),
     /// giving pre-declarations to insert before the outermost lambda expr.
     type RewriteState =
-        { rws_mustinline: bool
+        { rws_shouldinline: bool
           /// counts level of enclosing "lambdas"
           rws_innerLevel: int
           /// collected preDecs (fringe is in-order)
           rws_preDecs: Tree<LiftedDeclaration>
         }
 
-    let rewriteState0 = {rws_mustinline=false;rws_innerLevel=0;rws_preDecs=emptyTR}
+    let rewriteState0 = {rws_shouldinline=false;rws_innerLevel=0;rws_preDecs=emptyTR}
 
     // move in/out of lambdas (or lambda containing construct)
     let EnterInner z = {z with rws_innerLevel = z.rws_innerLevel + 1}
 
     let ExitInner  z = {z with rws_innerLevel = z.rws_innerLevel - 1}
 
-    let EnterMustInline b z f =
-        let orig = z.rws_mustinline
-        let x, z' = f (if b then {z with rws_mustinline = true } else z)
-        {z' with rws_mustinline = orig }, x
+    let EnterShouldInline b z f =
+        let orig = z.rws_shouldinline
+        let x, z' = f (if b then {z with rws_shouldinline = true } else z)
+        {z' with rws_shouldinline = orig }, x
 
     /// extract PreDecs (iff at top-level)
     let ExtractPreDecs z =
@@ -1263,8 +1269,8 @@ module Pass4_RewriteAssembly =
         TObjExprMethod(slotsig, attribs, tps, vs, e, m), z
 
     and TransBindingRhs penv z (TBind(v, e, letSeqPtOpt)) : Binding * RewriteState =
-        let mustInline = v.MustInline
-        let z, e = EnterMustInline mustInline z (fun z -> TransExpr penv z e)
+        let shouldInline = v.ShouldInline
+        let z, e = EnterShouldInline shouldInline z (fun z -> TransExpr penv z e)
         TBind (v, e, letSeqPtOpt), z
 
     and TransDecisionTree penv z x: DecisionTree * RewriteState =
diff --git a/src/Compiler/Optimize/Optimizer.fs b/src/Compiler/Optimize/Optimizer.fs
index afdc0616505..fafb8184600 100644
--- a/src/Compiler/Optimize/Optimizer.fs
+++ b/src/Compiler/Optimize/Optimizer.fs
@@ -435,6 +435,7 @@ type cenv =
 
       stackGuard: StackGuard
 
+      realsig: bool
     }
 
     override x.ToString() = "<cenv>"
@@ -499,7 +500,7 @@ let rec IsPartialExprVal x =
     | SizeValue (_, a) -> IsPartialExprVal a
 
 let CheckInlineValueIsComplete (v: Val) res =
-    if v.MustInline && IsPartialExprVal res then
+    if v.ShouldInline && IsPartialExprVal res then
         errorR(Error(FSComp.SR.optValueMarkedInlineButIncomplete(v.DisplayName), v.Range))
         //System.Diagnostics.Debug.Assert(false, sprintf "Break for incomplete inline value %s" v.DisplayName)
 
@@ -557,7 +558,7 @@ let UnknownValInfo = { ValExprInfo=UnknownValue; ValMakesNoCriticalTailcalls=fal
 let mkValInfo info (v: Val) = { ValExprInfo=info.Info; ValMakesNoCriticalTailcalls= v.MakesNoCriticalTailcalls }
 
 (* Bind a value *)
-let BindInternalLocalVal cenv (v: Val) vval env = 
+let BindInternalLocalVal cenv (v: Val) vval env =
     let vval = if v.IsMutable then UnknownValInfo else vval
 
     match vval.ValExprInfo with 
@@ -565,7 +566,7 @@ let BindInternalLocalVal cenv (v: Val) vval env =
     | _ ->
         cenv.localInternalVals[v.Stamp] <- vval
         env
-        
+
 let BindExternalLocalVal cenv (v: Val) vval env = 
     let g = cenv.g
 
@@ -635,7 +636,7 @@ let GetInfoForLocalValue cenv env (v: Val) m =
             match env.localExternalVals.TryFind v.Stamp with 
             | Some vval -> vval
             | None -> 
-                if v.MustInline then
+                if v.ShouldInline then
                     errorR(Error(FSComp.SR.optValueMarkedInlineButWasNotBoundInTheOptEnv(fullDisplayTextOfValRef (mkLocalValRef v)), m))
                 UnknownValInfo 
 
@@ -663,7 +664,7 @@ let GetInfoForNonLocalVal cenv env (vref: ValRef) =
     if vref.IsDispatchSlot then 
         UnknownValInfo
     // REVIEW: optionally turn x-module on/off on per-module basis or  
-    elif cenv.settings.crossAssemblyOpt () || vref.MustInline then 
+    elif cenv.settings.crossAssemblyOpt () || vref.ShouldInline then 
         match TryGetInfoForNonLocalEntityRef env vref.nlr.EnclosingEntity.nlr with
         | Some structInfo ->
             match structInfo.ValInfos.TryFind vref with 
@@ -1415,7 +1416,7 @@ let AbstractOptimizationInfoToEssentials =
 
     let rec abstractModulInfo (ss: ModuleInfo) =
          { ModuleOrNamespaceInfos = NameMap.map (InterruptibleLazy.force >> abstractModulInfo >> notlazy) ss.ModuleOrNamespaceInfos
-           ValInfos = ss.ValInfos.Filter (fun (v, _) -> v.MustInline) }
+           ValInfos = ss.ValInfos.Filter (fun (v, _) -> v.ShouldInline) }
 
     and abstractLazyModulInfo ss = ss |> InterruptibleLazy.force |> abstractModulInfo |> notlazy
       
@@ -2354,8 +2355,17 @@ let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr =
     | Expr.Const (c, m, ty) -> 
         OptimizeConst cenv env expr (c, m, ty)
 
-    | Expr.Val (v, _vFlags, m) -> 
-        OptimizeVal cenv env expr (v, m)
+    | Expr.Val (v, _vFlags, m) ->
+        if not (v.Accessibility.IsPrivate) then
+            OptimizeVal cenv env expr (v, m)
+        else
+            expr,
+            { TotalSize = 10
+              FunctionSize = 1
+              HasEffect = false  
+              MightMakeCriticalTailcall=false
+              Info=UnknownValue }
+
 
     | Expr.Quote (ast, splices, isFromQueryExpression, m, ty) -> 
           let doData data = map3Of4 (List.map (OptimizeExpr cenv env >> fst)) data
@@ -3035,8 +3045,7 @@ and CopyExprForInlining cenv isInlineIfLambda expr (m: range) =
 
 /// Make optimization decisions once we know the optimization information
 /// for a value
-and TryOptimizeVal cenv env (vOpt: ValRef option, mustInline, inlineIfLambda, valInfoForVal, m) = 
-
+and TryOptimizeVal cenv env (vOpt: ValRef option, shouldInline, inlineIfLambda, valInfoForVal, m) = 
     let g = cenv.g
 
     match valInfoForVal with 
@@ -3045,13 +3054,13 @@ and TryOptimizeVal cenv env (vOpt: ValRef option, mustInline, inlineIfLambda, va
         Some (Expr.Const (c, m, ty))
 
     | SizeValue (_, detail) ->
-        TryOptimizeVal cenv env (vOpt, mustInline, inlineIfLambda, detail, m) 
+        TryOptimizeVal cenv env (vOpt, shouldInline, inlineIfLambda, detail, m) 
 
     | ValValue (vR, detail) -> 
          // Inline values bound to other values immediately 
          // Prefer to inline using the more specific info if possible 
          // If the more specific info didn't reveal an inline then use the value 
-         match TryOptimizeVal cenv env (vOpt, mustInline, inlineIfLambda, detail, m) with 
+         match TryOptimizeVal cenv env (vOpt, shouldInline, inlineIfLambda, detail, m) with 
           | Some e -> Some e
           | None -> 
               // If we have proven 'v = compilerGeneratedValue'
@@ -3069,22 +3078,30 @@ and TryOptimizeVal cenv env (vOpt: ValRef option, mustInline, inlineIfLambda, va
     | ConstExprValue(_size, expr) ->
         Some (remarkExpr m (copyExpr g CloneAllAndMarkExprValsAsCompilerGenerated expr))
 
-    | CurriedLambdaValue (_, _, _, expr, _) when mustInline || inlineIfLambda ->
-        let exprCopy = CopyExprForInlining cenv inlineIfLambda expr m
-        Some exprCopy
+    | CurriedLambdaValue (_, _, _, expr, _) when shouldInline || inlineIfLambda ->
+        let fvs = freeInExpr CollectLocals expr
+        if fvs.UsesMethodLocalConstructs then
+            // Discarding lambda for binding because uses protected members --- TBD: Should we warn or error here
+            None 
+        elif fvs.FreeLocals |> Seq.exists(fun v -> v.Accessibility.IsPrivate ) then
+            // Discarding lambda for binding because uses private members --- TBD: Should we warn or error here
+            None
+        else
+            let exprCopy = CopyExprForInlining cenv inlineIfLambda expr m
+            Some exprCopy
 
-    | TupleValue _ | UnionCaseValue _ | RecdValue _ when mustInline ->
+    | TupleValue _ | UnionCaseValue _ | RecdValue _ when shouldInline ->
         failwith "tuple, union and record values cannot be marked 'inline'"
 
-    | UnknownValue when mustInline ->
+    | UnknownValue when shouldInline ->
         warning(Error(FSComp.SR.optValueMarkedInlineHasUnexpectedValue(), m))
         None
 
-    | _ when mustInline ->
+    | _ when shouldInline ->
         warning(Error(FSComp.SR.optValueMarkedInlineCouldNotBeInlined(), m))
         None
 
-    | _ -> None
+    | _ -> None 
   
 and TryOptimizeValInfo cenv env m vinfo = 
     if vinfo.HasEffect then None else TryOptimizeVal cenv env (None, false, false, vinfo.Info, m)
@@ -3109,7 +3126,7 @@ and OptimizeVal cenv env expr (v: ValRef, m) =
 
     let valInfoForVal = GetInfoForValWithCheck cenv env m v 
 
-    match TryOptimizeVal cenv env (Some v, v.MustInline, v.InlineIfLambda, valInfoForVal.ValExprInfo, m) with
+    match TryOptimizeVal cenv env (Some v, v.ShouldInline, v.InlineIfLambda, valInfoForVal.ValExprInfo, m) with
     | Some e -> 
        // don't reoptimize inlined lambdas until they get applied to something
        match e with 
@@ -3125,9 +3142,9 @@ and OptimizeVal cenv env expr (v: ValRef, m) =
            let e, einfo = OptimizeExpr cenv env e 
            e, AddValEqualityInfo g m v einfo 
 
-    | None -> 
-       if v.MustInline then
-           error(Error(FSComp.SR.optFailedToInlineValue(v.DisplayName), m))
+    | None ->
+       if v.ShouldInline then
+           warning(Error(FSComp.SR.optFailedToInlineValue(v.DisplayName), m))
        if v.InlineIfLambda then 
            warning(Error(FSComp.SR.optFailedToInlineSuggestedValue(v.DisplayName), m))
        expr, (AddValEqualityInfo g m v 
@@ -3578,45 +3595,46 @@ and OptimizeApplication cenv env (f0, f0ty, tyargs, args, m) =
     | Choice2Of2 (newf0, remake) -> 
 
     match TryInlineApplication cenv env finfo (tyargs, args, m) with 
-    | Some (res, info) -> 
+    | Some (res, info) ->
         // inlined
         (res |> remake), info
-    | None -> 
 
-    let shapes = 
-        match newf0 with 
-        | Expr.Val (vref, _, _) ->
-            match vref.ValReprInfo with
-            | Some(ValReprInfo(_, detupArgsL, _)) ->
-                let nargs = args.Length
-                let nDetupArgsL = detupArgsL.Length
-                let nShapes = min nargs nDetupArgsL 
-                let detupArgsShapesL = 
-                    List.truncate nShapes detupArgsL 
-                    |> List.map (fun detupArgs -> 
-                        match detupArgs with 
-                        | [] | [_] -> UnknownValue
-                        | _ -> TupleValue(Array.ofList (List.map (fun _ -> UnknownValue) detupArgs))) 
-                List.zip (detupArgsShapesL @ List.replicate (nargs - nShapes) UnknownValue) args
-            | _ -> args |> List.map (fun arg -> UnknownValue, arg)     
-        | _ -> args |> List.map (fun arg -> UnknownValue, arg) 
-
-    let newArgs, arginfos = OptimizeExprsThenReshapeAndConsiderSplits cenv env shapes
-    // beta reducing
-    let reducedExpr = MakeApplicationAndBetaReduce g (newf0, f0ty, [tyargs], newArgs, m) 
-    let newExpr = reducedExpr |> remake
-    
-    match newf0, reducedExpr with 
-    | (Expr.Lambda _ | Expr.TyLambda _), Expr.Let _ -> 
-       // we beta-reduced, hence reoptimize 
-        OptimizeExpr cenv env newExpr
     | _ -> 
-        // regular
 
-        // Determine if this application is a critical tailcall
-        let mayBeCriticalTailcall = 
+        let shapes = 
             match newf0 with 
-            | KnownValApp(vref, _typeArgs, otherArgs) ->
+            | Expr.Val (vref, _, _) ->
+                match vref.ValReprInfo with
+                | Some(ValReprInfo(_, detupArgsL, _)) ->
+                    let nargs = args.Length
+                    let nDetupArgsL = detupArgsL.Length
+                    let nShapes = min nargs nDetupArgsL 
+                    let detupArgsShapesL = 
+                        List.truncate nShapes detupArgsL 
+                        |> List.map (fun detupArgs -> 
+                            match detupArgs with 
+                            | [] | [_] -> UnknownValue
+                            | _ -> TupleValue(Array.ofList (List.map (fun _ -> UnknownValue) detupArgs))) 
+                    List.zip (detupArgsShapesL @ List.replicate (nargs - nShapes) UnknownValue) args
+                | _ -> args |> List.map (fun arg -> UnknownValue, arg)     
+            | _ -> args |> List.map (fun arg -> UnknownValue, arg) 
+
+        let newArgs, arginfos = OptimizeExprsThenReshapeAndConsiderSplits cenv env shapes
+        // beta reducing
+        let reducedExpr = MakeApplicationAndBetaReduce g (newf0, f0ty, [tyargs], newArgs, m) 
+        let newExpr = reducedExpr |> remake
+    
+        match newf0, reducedExpr with 
+        | (Expr.Lambda _ | Expr.TyLambda _), Expr.Let _ -> 
+           // we beta-reduced, hence reoptimize 
+            OptimizeExpr cenv env newExpr
+        | _ -> 
+            // regular
+
+            // Determine if this application is a critical tailcall
+            let mayBeCriticalTailcall = 
+                match newf0 with 
+                | KnownValApp(vref, _typeArgs, otherArgs) ->
 
                  // Check if this is a call to a function of known arity that has been inferred to not be a critical tailcall when used as a direct call
                  // This includes recursive calls to the function being defined (in which case we get a non-critical, closed-world tailcall).
@@ -3635,16 +3653,16 @@ and OptimizeApplication cenv env (f0, f0ty, tyargs, args, m) =
                     | None -> true // over-application of a known function, which presumably returns a function. This counts as an indirect call
                  else
                     true // application of a function that may make a critical tailcall
-                
-            | _ -> 
-                // All indirect calls (calls to unknown functions) are assumed to be critical tailcalls 
-                true
 
-        newExpr, { TotalSize=finfo.TotalSize + AddTotalSizes arginfos
-                   FunctionSize=finfo.FunctionSize + AddFunctionSizes arginfos
-                   HasEffect=true
-                   MightMakeCriticalTailcall = mayBeCriticalTailcall
-                   Info=ValueOfExpr newExpr }
+                | _ ->
+                    // All indirect calls (calls to unknown functions) are assumed to be critical tailcalls 
+                    true
+
+            newExpr, { TotalSize=finfo.TotalSize + AddTotalSizes arginfos
+                       FunctionSize=finfo.FunctionSize + AddFunctionSizes arginfos
+                       HasEffect=true
+                       MightMakeCriticalTailcall = mayBeCriticalTailcall
+                       Info=ValueOfExpr newExpr }
     
 /// Extract a sequence of pipe-right operations (note the pipe-right operator is left-associative
 /// so we start with the full thing and descend down taking apps off the end first)
@@ -4087,7 +4105,7 @@ and OptimizeBinding cenv isRec env (TBind(vref, expr, spBind)) =
         
         let exprOptimized, einfo = 
             let env = if vref.IsCompilerGenerated && Option.isSome env.latestBoundId then env else {env with latestBoundId=Some vref.Id} 
-            let cenv = if vref.InlineInfo.MustInline then { cenv with optimizing=false} else cenv 
+            let cenv = if vref.InlineInfo.ShouldInline then { cenv with optimizing=false} else cenv 
             let arityInfo = InferValReprInfoOfBinding g AllowTypeDirectedDetupling.No vref expr
             let exprOptimized, einfo = OptimizeLambdas (Some vref) cenv env arityInfo expr vref.Type 
             let size = localVarSize 
@@ -4106,6 +4124,9 @@ and OptimizeBinding cenv isRec env (TBind(vref, expr, spBind)) =
                     if fvs.UsesMethodLocalConstructs then
                         // Discarding lambda for binding because uses protected members
                         UnknownValue 
+                    elif fvs.FreeLocals.ToArray() |> Seq.fold(fun acc v -> if not acc then v.Accessibility.IsPrivate else acc) false then
+                        // Discarding lambda for binding because uses private members
+                        UnknownValue 
                     else
                         ivalue
 
@@ -4116,10 +4137,10 @@ and OptimizeBinding cenv isRec env (TBind(vref, expr, spBind)) =
             | UnknownValue | ConstValue _ | ConstExprValue _ -> ivalue
             | SizeValue(_, a) -> MakeSizedValueInfo (cut a) 
 
-        let einfo = if vref.MustInline || vref.InlineIfLambda then einfo else {einfo with Info = cut einfo.Info } 
+        let einfo = if vref.ShouldInline || vref.InlineIfLambda then einfo else {einfo with Info = cut einfo.Info } 
 
         let einfo = 
-            if (not vref.MustInline && not vref.InlineIfLambda && not cenv.settings.KeepOptimizationValues) ||
+            if (not vref.ShouldInline && not vref.InlineIfLambda && not cenv.settings.KeepOptimizationValues) ||
                
                // Bug 4916: do not record inline data for initialization trigger expressions
                // Note: we can't eliminate these value infos at the file boundaries because that would change initialization
@@ -4166,8 +4187,8 @@ and OptimizeBinding cenv isRec env (TBind(vref, expr, spBind)) =
                     valRefEq g nvref g.generic_hash_inner_vref))
             then {einfo with Info=UnknownValue} 
             else einfo 
-        if vref.MustInline && IsPartialExprVal einfo.Info then 
-            errorR(InternalError("the mustinline value '"+vref.LogicalName+"' was not inferred to have a known value", vref.Range))
+        if vref.ShouldInline && IsPartialExprVal einfo.Info then 
+            errorR(InternalError("the inline value '"+vref.LogicalName+"' was not inferred to have a known value", vref.Range))
         
         let env = BindInternalLocalVal cenv vref (mkValInfo einfo vref) env 
         (TBind(vref, exprOptimized, spBind), einfo), env
@@ -4366,7 +4387,8 @@ let OptimizeImplFile (settings, ccu, tcGlobals, tcVal, importMap, optEnv, isIncr
           localInternalVals=Dictionary<Stamp, ValInfo>(10000)
           emitTailcalls=emitTailcalls
           casApplied=Dictionary<Stamp, bool>() 
-          stackGuard = StackGuard(OptimizerStackGuardDepth, "OptimizerStackGuardDepth") 
+          stackGuard = StackGuard(OptimizerStackGuardDepth, "OptimizerStackGuardDepth")
+          realsig = tcGlobals.realsig
         }
 
     let env, _, _, _ as results = OptimizeImplFileInternal cenv optEnv isIncrementalFragment fsiMultiAssemblyEmit hidden mimpls  
diff --git a/src/Compiler/Service/FSharpProjectSnapshot.fs b/src/Compiler/Service/FSharpProjectSnapshot.fs
index 76d9705890e..6efd49f11c1 100644
--- a/src/Compiler/Service/FSharpProjectSnapshot.fs
+++ b/src/Compiler/Service/FSharpProjectSnapshot.fs
@@ -149,13 +149,13 @@ type internal FSharpParsedFile
         SyntaxTreeHash: byte array,
         SourceText: ISourceText,
         ParsedInput: ParsedInput,
-        ParseErrors: (PhasedDiagnostic * FSharpDiagnosticSeverity)[]
+        ParseDiagnostics: (PhasedDiagnostic * FSharpDiagnosticSeverity)[]
     ) =
 
     member _.FileName = FileName
     member _.SourceText = SourceText
     member _.ParsedInput = ParsedInput
-    member _.ParseErrors = ParseErrors
+    member _.ParseDiagnostics = ParseDiagnostics
 
     member val IsSignatureFile = FileName |> isSignatureFile
 
diff --git a/src/Compiler/Service/ServiceLexing.fs b/src/Compiler/Service/ServiceLexing.fs
index bc967f30dbe..9abe2199dc0 100644
--- a/src/Compiler/Service/ServiceLexing.fs
+++ b/src/Compiler/Service/ServiceLexing.fs
@@ -36,7 +36,7 @@ module FSharpTokenTag =
         tagOfToken (INTERP_STRING_BEGIN_PART("a", SynStringKind.Regular, LexCont.Default))
 
     let INTERP_STRING_PART = tagOfToken (INTERP_STRING_PART("a", LexCont.Default))
-    let INTERP_STRING_END = tagOfToken (INTERP_STRING_END("a", None, LexCont.Default))
+    let INTERP_STRING_END = tagOfToken (INTERP_STRING_END("a", LexCont.Default))
     let LPAREN = tagOfToken LPAREN
     let RPAREN = tagOfToken RPAREN
     let LBRACK = tagOfToken LBRACK
@@ -493,7 +493,7 @@ module internal LexerStateEncoding =
         | INTERP_STRING_BEGIN_PART(_, _, cont)
         | INTERP_STRING_PART(_, cont)
         | INTERP_STRING_BEGIN_END(_, _, cont)
-        | INTERP_STRING_END(_, _, cont)
+        | INTERP_STRING_END(_, cont)
         | LBRACE cont
         | RBRACE cont
         | BYTEARRAY(_, _, cont)
diff --git a/src/Compiler/Service/TransparentCompiler.fs b/src/Compiler/Service/TransparentCompiler.fs
index c5ecfba812f..f13b7be6d69 100644
--- a/src/Compiler/Service/TransparentCompiler.fs
+++ b/src/Compiler/Service/TransparentCompiler.fs
@@ -1251,7 +1251,9 @@ type internal TransparentCompiler
 
                 let sink = TcResultsSinkImpl(tcGlobals, file.SourceText)
 
-                let hadParseErrors = not (Array.isEmpty file.ParseErrors)
+                let hadParseErrors =
+                    file.ParseDiagnostics
+                    |> Array.exists (snd >> (=) FSharpDiagnosticSeverity.Error)
 
                 let input, moduleNamesDict =
                     DeduplicateParsedInputModuleName prevTcInfo.moduleNamesDict input
@@ -1448,7 +1450,7 @@ type internal TransparentCompiler
                     tcConfig.diagnosticsOptions,
                     false,
                     file.FileName,
-                    parsedFile.ParseErrors,
+                    parsedFile.ParseDiagnostics,
                     suggestNamesForErrors,
                     tcConfig.flatErrors,
                     None
diff --git a/src/Compiler/Symbols/Symbols.fs b/src/Compiler/Symbols/Symbols.fs
index b5b244a6e5c..19fbfe9306b 100644
--- a/src/Compiler/Symbols/Symbols.fs
+++ b/src/Compiler/Symbols/Symbols.fs
@@ -32,9 +32,9 @@ type FSharpAccessibility(a:Accessibility, ?isProtected) =
 
     let isInternalCompPath x = 
         match x with 
-        | CompPath(ILScopeRef.Local, []) -> true 
+        | CompPath(ILScopeRef.Local, _, []) -> true 
         | _ -> false
-    
+
     let (|Public|Internal|Private|) (TAccess p) = 
         match p with 
         | [] -> Public 
@@ -53,7 +53,7 @@ type FSharpAccessibility(a:Accessibility, ?isProtected) =
 
     override _.ToString() = 
         let (TAccess paths) = a
-        let mangledTextOfCompPath (CompPath(scoref, path)) = getNameOfScopeRef scoref + "/" + textOfPath (List.map fst path)  
+        let mangledTextOfCompPath (CompPath(scoref, _, path)) = getNameOfScopeRef scoref + "/" + textOfPath (List.map fst path)  
         String.concat ";" (List.map mangledTextOfCompPath paths)
 
 type SymbolEnv(g: TcGlobals, thisCcu: CcuThunk, thisCcuTyp: ModuleOrNamespaceType option, tcImports: TcImports, amap: Import.ImportMap, infoReader: InfoReader) = 
@@ -122,7 +122,7 @@ module Impl =
                 | ILScopeRef.Assembly aref -> aref.Name 
                 | ILScopeRef.Module mref -> mref.Name
                 | ILScopeRef.PrimaryAssembly -> ilg.primaryAssemblyName
-            let canAccessCompPathFromCrossProject (CompPath(scoref1, cpath1)) (CompPath(scoref2, cpath2)) =
+            let canAccessCompPathFromCrossProject (CompPath(scoref1, _, cpath1)) (CompPath(scoref2, _, cpath2)) =
                 let rec loop p1 p2  = 
                     match p1, p2 with 
                     | (a1, k1) :: rest1, (a2, k2) :: rest2 -> (a1=a2) && (k1=k2) && loop rest1 rest2
@@ -141,7 +141,7 @@ module Impl =
         | ILMemberAccess.CompilerControlled
         | ILMemberAccess.FamilyAndAssembly 
         | ILMemberAccess.Assembly -> 
-            taccessPrivate  (CompPath(declaringEntity.CompilationPath.ILScopeRef, []))
+            taccessPrivate  (CompPath(declaringEntity.CompilationPath.ILScopeRef, SyntaxAccess.Unknown, []))
 
         | ILMemberAccess.Private ->
             taccessPrivate  declaringEntity.CompilationPath
@@ -166,7 +166,7 @@ module Impl =
             match td.Access with 
             | ILTypeDefAccess.Public 
             | ILTypeDefAccess.Nested ILMemberAccess.Public -> taccessPublic 
-            | ILTypeDefAccess.Private  -> taccessPrivate  (CompPath(entity.CompilationPath.ILScopeRef, []))
+            | ILTypeDefAccess.Private  -> taccessPrivate  (CompPath(entity.CompilationPath.ILScopeRef, SyntaxAccess.Unknown, []))
             | ILTypeDefAccess.Nested nested -> getApproxFSharpAccessibilityOfMember entity nested
 
         | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> 
@@ -409,13 +409,13 @@ type FSharpEntity(cenv: SymbolEnv, entity: EntityRef, tyargs: TType list) =
         checkIsResolved()
         match entity.CompilationPathOpt with 
         | None -> "global" 
-        | Some (CompPath(_, [])) -> "global" 
+        | Some (CompPath(_, _, [])) -> "global" 
         | Some cp -> buildAccessPath (Some cp)
     
     member x.DeclaringEntity = 
         match entity.CompilationPathOpt with 
         | None -> None
-        | Some (CompPath(_, [])) -> None
+        | Some (CompPath(_, _, [])) -> None
         | Some cp -> 
             match x.Assembly.Contents.FindEntityByPath cp.MangledPath with
             | Some res -> Some res
@@ -431,7 +431,7 @@ type FSharpEntity(cenv: SymbolEnv, entity: EntityRef, tyargs: TType list) =
         checkIsResolved()
         match entity.CompilationPathOpt with 
         | None -> None
-        | Some (CompPath(_, [])) -> None
+        | Some (CompPath(_, _, [])) -> None
         | Some cp when cp.AccessPath |> List.forall (function _, ModuleOrNamespaceKind.Namespace _ -> true | _  -> false) -> 
             Some (buildAccessPath (Some cp))
         | Some _ -> None
@@ -774,7 +774,7 @@ type FSharpEntity(cenv: SymbolEnv, entity: EntityRef, tyargs: TType list) =
 
     member _.AllCompilationPaths =
         checkIsResolved()
-        let (CompPath(_, parts)) = entity.CompilationPath
+        let (CompPath(_, _, parts)) = entity.CompilationPath
         let partsList =
             [ yield parts
               match parts with
diff --git a/src/Compiler/SyntaxTree/LexHelpers.fs b/src/Compiler/SyntaxTree/LexHelpers.fs
index 5ee9a16c90b..02d4da364d4 100644
--- a/src/Compiler/SyntaxTree/LexHelpers.fs
+++ b/src/Compiler/SyntaxTree/LexHelpers.fs
@@ -190,7 +190,7 @@ type LexerStringFinisher =
                 else if isPart then
                     INTERP_STRING_PART(s, cont)
                 else
-                    INTERP_STRING_END(s, None, cont)
+                    INTERP_STRING_END(s, cont)
             elif kind.IsByteString then
                 let synByteStringKind =
                     if isVerbatim then
diff --git a/src/Compiler/TypedTree/TcGlobals.fs b/src/Compiler/TypedTree/TcGlobals.fs
index 3830dd008e5..4f713fb4d5d 100644
--- a/src/Compiler/TypedTree/TcGlobals.fs
+++ b/src/Compiler/TypedTree/TcGlobals.fs
@@ -193,7 +193,8 @@ type TcGlobals(
     emitDebugInfoInQuotations: bool,
     noDebugAttributes: bool,
     pathMap: PathMap,
-    langVersion: LanguageVersion) =
+    langVersion: LanguageVersion,
+    realsig: bool) =
 
   // empty flags
   let v_knownWithoutNull = 0uy
@@ -354,7 +355,7 @@ type TcGlobals(
           let attrRef = ILTypeRef.Create(ILScopeRef.Local, [], nm)
           let attrTycon =
              Construct.NewTycon(
-                 Some (CompPath(ILScopeRef.Local, [])),
+                 Some (CompPath(ILScopeRef.Local, SyntaxAccess.Internal, [])),
                  attrRef.Name,
                  range0,
                  taccessInternal,
@@ -1104,6 +1105,8 @@ type TcGlobals(
 
   member _.langVersion = langVersion
 
+  member _.realsig = realsig
+
   member _.unionCaseRefEq x y = primUnionCaseRefEq compilingFSharpCore fslibCcu x y
 
   member _.valRefEq x y = primValRefEq compilingFSharpCore fslibCcu x y
diff --git a/src/Compiler/TypedTree/TypedTree.fs b/src/Compiler/TypedTree/TypedTree.fs
index da8e43bfba5..7c2a454ae36 100644
--- a/src/Compiler/TypedTree/TypedTree.fs
+++ b/src/Compiler/TypedTree/TypedTree.fs
@@ -48,8 +48,8 @@ type ValInline =
     /// Indicates the value must never be inlined by the optimizer
     | Never
 
-    /// Returns true if the implementation of a value must always be inlined
-    member x.MustInline = 
+    /// Returns true if the implementation of a value should be inlined
+    member x.ShouldInline = 
         match x with 
         | ValInline.Always -> true 
         | ValInline.Optional | ValInline.Never -> false
@@ -519,14 +519,21 @@ type PublicPath =
         assert (pp.Length >= 1)
         pp[0..pp.Length-2]
 
+/// Represents the specified visibility of the accessibility -- used to ensure IL visibility
+[<RequireQualifiedAccess>]
+type SyntaxAccess =
+    | Public
+    | Internal
+    | Private
+    | Unknown
 
 /// The information ILXGEN needs about the location of an item
-type CompilationPath = 
-    | CompPath of ILScopeRef * (string * ModuleOrNamespaceKind) list
+type CompilationPath =
+    | CompPath of ILScopeRef * SyntaxAccess * (string * ModuleOrNamespaceKind) list
 
-    member x.ILScopeRef = let (CompPath(scoref, _)) = x in scoref
+    member x.ILScopeRef = let (CompPath(scoref, _, _)) = x in scoref
 
-    member x.AccessPath = let (CompPath(_, p)) = x in p
+    member x.AccessPath = let (CompPath(_, _, p)) = x in p
 
     member x.MangledPath = List.map fst x.AccessPath
 
@@ -534,10 +541,10 @@ type CompilationPath =
 
     member x.ParentCompPath = 
         let a, _ = List.frontAndBack x.AccessPath
-        CompPath(x.ILScopeRef, a)
+        CompPath(x.ILScopeRef, x.SyntaxAccess, a)
 
     member x.NestedCompPath n moduleKind =
-        CompPath(x.ILScopeRef, x.AccessPath@[(n, moduleKind)])
+        CompPath(x.ILScopeRef, x.SyntaxAccess, x.AccessPath@[(n, moduleKind)])
 
     member x.DemangledPath = 
         x.AccessPath |> List.map (fun (nm, k) -> CompilationPath.DemangleEntityName nm k)
@@ -548,6 +555,8 @@ type CompilationPath =
         | FSharpModuleWithSuffix -> String.dropSuffix nm FSharpModuleSuffix
         | _ -> nm
 
+    member x.SyntaxAccess = let (CompPath(_, access, _)) = x in access
+
 [<NoEquality; NoComparison; StructuredFormatDisplay("{DebugText}")>]
 type EntityOptionalData =
     {
@@ -1271,7 +1280,7 @@ type Entity =
         | TProvidedNamespaceRepr _ -> failwith "No compiled representation for provided namespace"
         | _ ->
 #endif
-            let ilTypeRefForCompilationPath (CompPath(sref, p)) item = 
+            let ilTypeRefForCompilationPath (CompPath(sref, _, p)) item = 
                 let rec top racc p = 
                     match p with 
                     | [] -> ILTypeRef.Create(sref, [], textOfPath (List.rev (item :: racc)))
@@ -2138,19 +2147,78 @@ type ModuleOrNamespaceType(kind: ModuleOrNamespaceKind, vals: QueueList<Val>, en
 type ModuleOrNamespace = Entity 
 
 /// Represents a type or exception definition in the typed AST
-type Tycon = Entity 
+type Tycon = Entity
+
+let getNameOfScopeRef sref = 
+    match sref with 
+    | ILScopeRef.Local -> "<local>"
+    | ILScopeRef.Module mref -> mref.Name
+    | ILScopeRef.Assembly aref -> aref.Name
+    | ILScopeRef.PrimaryAssembly -> "<primary>"
+
+let private isInternalCompPath x =
+    match x with
+    | CompPath(ILScopeRef.Local, _, []) -> true
+    | _ -> false
+
+let private (|Public|Internal|Private|) (TAccess p) =
+    match p with
+    | [] -> Public
+    | _ when List.forall isInternalCompPath p -> Internal 
+    | _ -> Private
+
+let getSyntaxAccessForCompPath (TAccess a) = match a with | CompPath(_, sa, _) :: _ -> sa | _ -> TypedTree.SyntaxAccess.Unknown
+
+let updateSyntaxAccessForCompPath access syntaxAccess =
+    match access with
+    | CompPath(sc, sa, p) :: rest when sa <> syntaxAccess -> ([CompPath(sc, syntaxAccess, p)]@rest)
+    | _ -> access
 
 /// Represents the constraint on access for a construct
 [<StructuralEquality; NoComparison; StructuredFormatDisplay("{DebugText}")>]
-type Accessibility = 
-
+type Accessibility =
     /// Indicates the construct can only be accessed from any code in the given type constructor, module or assembly. [] indicates global scope. 
     | TAccess of compilationPaths: CompilationPath list
-    
+
+    member public x.IsPublic = match x with Public -> true | _ -> false
+
+    member public x.IsInternal = match x with Internal -> true | _ -> false
+
+    member public x.IsPrivate = match x with Private -> true | _ -> false
+
     [<DebuggerBrowsable(DebuggerBrowsableState.Never)>]
     member x.DebugText = x.ToString()
 
-    override x.ToString() = "Accessibility(...)"
+    member x.AsILMemberAccess () =
+        match getSyntaxAccessForCompPath x with
+        | TypedTree.SyntaxAccess.Public -> ILMemberAccess.Public
+        | TypedTree.SyntaxAccess.Internal -> ILMemberAccess.Assembly
+        | TypedTree.SyntaxAccess.Private -> ILMemberAccess.Private
+        | _ ->
+            if x.IsPublic then ILMemberAccess.Public
+            elif x.IsInternal then ILMemberAccess.Assembly
+            else ILMemberAccess.Private
+
+    member x.AsILTypeDefAccess () =
+        if x.IsPublic then ILTypeDefAccess.Public
+        else ILTypeDefAccess.Private
+
+    member x.CompilationPaths = match x with | TAccess compilationPaths -> compilationPaths
+
+    override x.ToString() =
+        match x with
+        | TAccess (paths) ->
+            let mangledTextOfCompPath (CompPath(scoref, _, path)) = getNameOfScopeRef scoref + "/" + textOfPath (List.map fst path)  
+            let scopename =
+                if x.IsPublic then "public"
+                elif x.IsInternal then "internal"
+                else "private"
+            let paths = String.concat ";" (List.map mangledTextOfCompPath paths)
+            if paths = "" then
+                scopename
+            else
+                $"{scopename} {paths}"
+
 
 /// Represents less-frequently-required data about a type parameter of type inference variable
 [<NoEquality; NoComparison; StructuredFormatDisplay("{DebugText}")>]
@@ -2906,8 +2974,8 @@ type Val =
     /// Determines if the values is implied by another construct, e.g. a `IsA` property is implied by the union case for A
     member x.IsImplied = x.val_flags.IsImplied
 
-    /// Indicates whether the inline declaration for the value indicate that the value must be inlined?
-    member x.MustInline = x.InlineInfo.MustInline
+    /// Indicates whether the inline declaration for the value indicate that the value should be inlined?
+    member x.ShouldInline = x.InlineInfo.ShouldInline
 
     /// Indicates whether this value was generated by the compiler.
     ///
@@ -4065,7 +4133,7 @@ type ValRef =
     member x.InlineIfLambda = x.Deref.InlineIfLambda
 
     /// Indicates whether the inline declaration for the value indicate that the value must be inlined?
-    member x.MustInline = x.Deref.MustInline
+    member x.ShouldInline = x.Deref.ShouldInline
 
     /// Indicates whether this value was generated by the compiler.
     ///
@@ -5898,7 +5966,7 @@ type Construct() =
             | None -> 
                 let ilScopeRef = st.TypeProviderAssemblyRef
                 let enclosingName = GetFSharpPathToProvidedType(st, m)
-                CompPath(ilScopeRef, enclosingName |> List.map(fun id->id, ModuleOrNamespaceKind.Namespace true))
+                CompPath(ilScopeRef, SyntaxAccess.Unknown, enclosingName |> List.map(fun id->id, ModuleOrNamespaceKind.Namespace true))
             | Some p -> p
         let pubpath = cpath.NestedPublicPath id
 
@@ -6127,7 +6195,7 @@ type Construct() =
 
     /// Create the new contents of an overall assembly
     static member NewCcuContents sref m nm mty =
-        Construct.NewModuleOrNamespace (Some(CompPath(sref, []))) taccessPublic (ident(nm, m)) XmlDoc.Empty [] (MaybeLazy.Strict mty)
+        Construct.NewModuleOrNamespace (Some(CompPath(sref, SyntaxAccess.Unknown, []))) taccessPublic (ident(nm, m)) XmlDoc.Empty [] (MaybeLazy.Strict mty)
 
     /// Create a tycon based on an existing one using the function 'f'. 
     /// We require that we be given the new parent for the new tycon. 
diff --git a/src/Compiler/TypedTree/TypedTree.fsi b/src/Compiler/TypedTree/TypedTree.fsi
index 7f0a0ef4ed3..00aee7a92ef 100644
--- a/src/Compiler/TypedTree/TypedTree.fsi
+++ b/src/Compiler/TypedTree/TypedTree.fsi
@@ -17,6 +17,8 @@ open FSharp.Compiler.TypeProviders
 open FSharp.Compiler.Xml
 open FSharp.Core.CompilerServices
 
+val getNameOfScopeRef: sref: ILScopeRef -> string
+
 type Stamp = int64
 
 type StampMap<'T> = Map<Stamp, 'T>
@@ -34,7 +36,7 @@ type ValInline =
     | Never
 
     /// Returns true if the implementation of a value must always be inlined
-    member MustInline: bool
+    member ShouldInline: bool
 
 /// A flag associated with values that indicates whether the recursive scope of the value is currently being processed, type
 /// if the value has been generalized or not as yet.
@@ -320,9 +322,17 @@ type PublicPath =
 
     member EnclosingPath: string[]
 
+/// Represents the specified visibility of the accessibility -- used to ensure IL visibility
+[<RequireQualifiedAccess>]
+type SyntaxAccess =
+    | Public
+    | Internal
+    | Private
+    | Unknown
+
 /// The information ILXGEN needs about the location of an item
 type CompilationPath =
-    | CompPath of ILScopeRef * (string * ModuleOrNamespaceKind) list
+    | CompPath of ILScopeRef * SyntaxAccess * (string * ModuleOrNamespaceKind) list
 
     /// String 'Module' off an F# module name, if FSharpModuleWithSuffix is used
     static member DemangleEntityName: nm: string -> k: ModuleOrNamespaceKind -> string
@@ -341,6 +351,8 @@ type CompilationPath =
 
     member ParentCompPath: CompilationPath
 
+    member SyntaxAccess: SyntaxAccess
+
 [<NoEquality; NoComparison; StructuredFormatDisplay("{DebugText}")>]
 type EntityOptionalData =
     {
@@ -1424,6 +1436,8 @@ type ModuleOrNamespace = Entity
 /// Represents a type or exception definition in the typed AST
 type Tycon = Entity
 
+val updateSyntaxAccessForCompPath: CompilationPath list -> TypedTree.SyntaxAccess -> CompilationPath list
+
 /// Represents the constraint on access for a construct
 [<StructuralEquality; NoComparison; StructuredFormatDisplay("{DebugText}")>]
 type Accessibility =
@@ -1431,6 +1445,19 @@ type Accessibility =
     /// Indicates the construct can only be accessed from any code in the given type constructor, module or assembly. [] indicates global scope.
     | TAccess of compilationPaths: CompilationPath list
 
+    member AsILMemberAccess: unit -> ILMemberAccess
+
+    member AsILTypeDefAccess: unit -> ILTypeDefAccess
+
+    member CompilationPaths: CompilationPath list
+
+    member IsPublic: bool
+
+    member IsInternal: bool
+
+    member IsPrivate: bool
+
+    /// Readable rendering of Accessibility
     override ToString: unit -> string
 
     [<DebuggerBrowsable(DebuggerBrowsableState.Never)>]
@@ -2155,8 +2182,8 @@ type Val =
     /// a true body. These cases are often causes of bugs in the compiler.
     member MemberInfo: ValMemberInfo option
 
-    /// Indicates whether the inline declaration for the value indicate that the value must be inlined?
-    member MustInline: bool
+    /// Indicates whether the inline declaration for the value indicates that the value should be inlined.
+    member ShouldInline: bool
 
     /// Get the number of 'this'/'self' object arguments for the member. Instance extension members return '1'.
     member NumObjArgs: int
@@ -2870,8 +2897,8 @@ type ValRef =
     /// Is this a member, if so some more data about the member.
     member MemberInfo: ValMemberInfo option
 
-    /// Indicates whether the inline declaration for the value indicate that the value must be inlined?
-    member MustInline: bool
+    /// Indicates whether the inline declaration for the value indicate that the value should be inlined?
+    member ShouldInline: bool
 
     /// Get the number of 'this'/'self' object arguments for the member. Instance extension members return '1'.
     member NumObjArgs: int
diff --git a/src/Compiler/TypedTree/TypedTreeBasics.fs b/src/Compiler/TypedTree/TypedTreeBasics.fs
index c71994685d3..1fca2981579 100644
--- a/src/Compiler/TypedTree/TypedTreeBasics.fs
+++ b/src/Compiler/TypedTree/TypedTreeBasics.fs
@@ -19,13 +19,6 @@ assert (sizeof<EntityFlags> = 8)
 assert (sizeof<TyparFlags> = 4)
 #endif
 
-let getNameOfScopeRef sref = 
-    match sref with 
-    | ILScopeRef.Local -> "<local>"
-    | ILScopeRef.Module mref -> mref.Name
-    | ILScopeRef.Assembly aref -> aref.Name
-    | ILScopeRef.PrimaryAssembly -> "<primary>"
-
 /// Metadata on values (names of arguments etc.) 
 module ValReprInfo = 
 
@@ -436,11 +429,11 @@ let primValRefEq compilingFSharpCore fslibCcu (x: ValRef) (y: ValRef) =
 //---------------------------------------------------------------------------
 
 let fullCompPathOfModuleOrNamespace (m: ModuleOrNamespace) = 
-    let (CompPath(scoref, cpath)) = m.CompilationPath
-    CompPath(scoref, cpath@[(m.LogicalName, m.ModuleOrNamespaceType.ModuleOrNamespaceKind)])
+    let (CompPath(scoref, sa, cpath)) = m.CompilationPath
+    CompPath(scoref, sa, cpath@[(m.LogicalName, m.ModuleOrNamespaceType.ModuleOrNamespaceKind)])
 
 // Can cpath2 be accessed given a right to access cpath1. That is, is cpath2 a nested type or namespace of cpath1. Note order of arguments.
-let inline canAccessCompPathFrom (CompPath(scoref1, cpath1)) (CompPath(scoref2, cpath2)) =
+let inline canAccessCompPathFrom (CompPath(scoref1, _, cpath1)) (CompPath(scoref2, _, cpath2)) =
     let rec loop p1 p2 = 
         match p1, p2 with 
         | (a1, k1) :: rest1, (a2, k2) :: rest2 -> (a1=a2) && (k1=k2) && loop rest1 rest2
@@ -465,12 +458,20 @@ let accessSubstPaths (newPath, oldPath) (TAccess paths) =
     let subst cpath = if cpath=oldPath then newPath else cpath
     TAccess (List.map subst paths)
 
-let compPathOfCcu (ccu: CcuThunk) = CompPath(ccu.ILScopeRef, []) 
+let compPathOfCcu (ccu: CcuThunk) = CompPath(ccu.ILScopeRef, SyntaxAccess.Unknown, []) 
 let taccessPublic = TAccess []
-let taccessPrivate accessPath = TAccess [accessPath]
-let compPathInternal = CompPath(ILScopeRef.Local, [])
+let compPathInternal = CompPath(ILScopeRef.Local, SyntaxAccess.Internal, [])
 let taccessInternal = TAccess [compPathInternal]
-let combineAccess (TAccess a1) (TAccess a2) = TAccess(a1@a2)
+let taccessPrivate accessPath = let (CompPath(sc,_, paths)) = accessPath in TAccess [CompPath(sc, TypedTree.SyntaxAccess.Private, paths)]
+
+let combineAccess access1 access2 =
+    let (TAccess a1) = access1
+    let (TAccess a2) = access2
+    let combined =
+        if access1 = taccessPublic then updateSyntaxAccessForCompPath (a1@a2) TypedTree.SyntaxAccess.Public
+        elif access1 = taccessInternal then updateSyntaxAccessForCompPath (a1@a2) TypedTree.SyntaxAccess.Internal
+        else (a1@a2)
+    TAccess combined
 
 exception Duplicate of string * string * range
 exception NameClash of string * string * string * range * string * string * range
diff --git a/src/Compiler/TypedTree/TypedTreeBasics.fsi b/src/Compiler/TypedTree/TypedTreeBasics.fsi
index ea1f5979262..c3edc900871 100644
--- a/src/Compiler/TypedTree/TypedTreeBasics.fsi
+++ b/src/Compiler/TypedTree/TypedTreeBasics.fsi
@@ -12,8 +12,6 @@ open FSharp.Compiler.Syntax
 open FSharp.Compiler.Text
 open FSharp.Compiler.TypedTree
 
-val getNameOfScopeRef: sref: ILScopeRef -> string
-
 /// Metadata on values (names of arguments etc.
 module ValReprInfo =
 
diff --git a/src/Compiler/TypedTree/TypedTreeOps.fs b/src/Compiler/TypedTree/TypedTreeOps.fs
index 8ef6ce62182..68b924df6a2 100644
--- a/src/Compiler/TypedTree/TypedTreeOps.fs
+++ b/src/Compiler/TypedTree/TypedTreeOps.fs
@@ -1198,7 +1198,7 @@ let mkMultiLambdaTy g m vs bodyTy = mkFunTy g (typeOfLambdaArg m vs) bodyTy
 /// the library arising from env.fs. Part of this means that we have to be able to resolve these
 /// references. This function artificially forces the existence of a module or namespace at a 
 /// particular point in order to do this.
-let ensureCcuHasModuleOrNamespaceAtPath (ccu: CcuThunk) path (CompPath(_, cpath)) xml =
+let ensureCcuHasModuleOrNamespaceAtPath (ccu: CcuThunk) path (CompPath(_, sa, cpath)) xml =
     let scoref = ccu.ILScopeRef 
     let rec loop prior_cpath (path: Ident list) cpath (modul: ModuleOrNamespace) =
         let mtype = modul.ModuleOrNamespaceType 
@@ -1207,7 +1207,7 @@ let ensureCcuHasModuleOrNamespaceAtPath (ccu: CcuThunk) path (CompPath(_, cpath)
             let modName = hpath.idText 
             if not (Map.containsKey modName mtype.AllEntitiesByCompiledAndLogicalMangledNames) then 
                 let mty = Construct.NewEmptyModuleOrNamespaceType mkind
-                let cpath = CompPath(scoref, prior_cpath)
+                let cpath = CompPath(scoref, sa, prior_cpath)
                 let smodul = Construct.NewModuleOrNamespace (Some cpath) taccessPublic hpath xml [] (MaybeLazy.Strict mty)
                 mtype.AddModuleOrNamespaceByMutation smodul
             let modul = Map.find modName mtype.AllEntitiesByCompiledAndLogicalMangledNames 
@@ -4150,7 +4150,7 @@ module DebugPrint =
 
     let typeOfValL (v: Val) =
         valL v
-          ^^ (if v.MustInline then wordL (tagText "inline ") else emptyL) 
+          ^^ (if v.ShouldInline then wordL (tagText "inline ") else emptyL) 
           ^^ (if v.IsMutable then wordL(tagText "mutable ") else emptyL)
           ^^ (if layoutTypes then wordL (tagText ":") ^^ typeL v.Type else emptyL)
 
@@ -4940,20 +4940,36 @@ let rec accImplHidingInfoAtAssemblyBoundary mdef acc =
 let ComputeImplementationHidingInfoAtAssemblyBoundary mty acc = 
     accImplHidingInfoAtAssemblyBoundary mty acc
 
+let DoRemap setF remapF = 
+    let rec remap mrmi x =
+
+        match mrmi with
+         | [] -> x
+         | (rpi, mhi) :: rest ->
+            // Explicitly hidden?
+            if Zset.contains x (setF mhi) then
+                x
+            else
+                remap rest (remapF rpi x)
+    fun mrmi x -> remap mrmi x
+
+let DoRemapTycon mrmi x = DoRemap (fun mhi -> mhi.HiddenTycons) (fun rpi x -> (remapTyconRef rpi.tyconRefRemap (mkLocalTyconRef x)).Deref) mrmi x
+
+let DoRemapVal mrmi x = DoRemap (fun mhi -> mhi.HiddenVals) (fun rpi x -> (remapValRef rpi (mkLocalValRef x)).Deref) mrmi x 
+
 //--------------------------------------------------------------------------
 // Compute instances of the above for mexpr -> mty
 //--------------------------------------------------------------------------
-
 let IsHidden setF accessF remapF = 
-    let rec check mrmi x = 
-            // Internal/private? 
-        not (canAccessFromEverywhere (accessF x)) || 
-        (match mrmi with 
-         | [] -> false // Ah! we escaped to freedom! 
-         | (rpi, mhi) :: rest -> 
-            // Explicitly hidden? 
-            Zset.contains x (setF mhi) || 
-            // Recurse... 
+    let rec check mrmi x =
+        // Internal/private?
+        not (canAccessFromEverywhere (accessF x)) ||
+        (match mrmi with
+         | [] -> false // Ah! we escaped to freedom!
+         | (rpi, mhi) :: rest ->
+            // Explicitly hidden?
+            Zset.contains x (setF mhi) ||
+            // Recurse...
             check rest (remapF rpi x))
     check
 
@@ -5752,7 +5768,7 @@ and mapImmediateValsAndTycons ft fv (x: ModuleOrNamespaceType) =
     let vals = x.AllValsAndMembers |> QueueList.map fv
     let tycons = x.AllEntities |> QueueList.map ft
     ModuleOrNamespaceType(x.ModuleOrNamespaceKind, vals, tycons)
-    
+
 and copyVal compgen (v: Val) = 
     match compgen with 
     | OnlyCloneExprVals when v.IsMemberOrModuleBinding -> v
@@ -6129,10 +6145,7 @@ and copyAndRemapAndBindModTy ctxt compgen tmenv mty =
     let tycons = allEntitiesOfModuleOrNamespaceTy mty
     let vs = allValsOfModuleOrNamespaceTy mty
     let _, _, tmenvinner = copyAndRemapAndBindTyconsAndVals ctxt compgen tmenv tycons vs
-    remapModTy compgen tmenvinner mty, tmenvinner
-
-and remapModTy _compgen tmenv mty = 
-    mapImmediateValsAndTycons (renameTycon tmenv) (renameVal tmenv) mty 
+    (mapImmediateValsAndTycons (renameTycon tmenvinner) (renameVal tmenvinner) mty), tmenvinner
 
 and renameTycon tyenv x = 
     let tcref = 
diff --git a/src/Compiler/TypedTree/TypedTreeOps.fsi b/src/Compiler/TypedTree/TypedTreeOps.fsi
index bec1e031185..534eefc7762 100755
--- a/src/Compiler/TypedTree/TypedTreeOps.fsi
+++ b/src/Compiler/TypedTree/TypedTreeOps.fsi
@@ -1331,6 +1331,12 @@ val MakeExportRemapping: CcuThunk -> ModuleOrNamespace -> Remap
 /// Make a remapping table for viewing a module or namespace 'from the outside'
 val ApplyExportRemappingToEntity: TcGlobals -> Remap -> ModuleOrNamespace -> ModuleOrNamespace
 
+/// Get the value including fsi remapping
+val DoRemapTycon: (Remap * SignatureHidingInfo) list -> Tycon -> Tycon
+
+/// Get the value including fsi remapping
+val DoRemapVal: (Remap * SignatureHidingInfo) list -> Val -> Val
+
 /// Determine if a type definition is hidden by a signature
 val IsHiddenTycon: (Remap * SignatureHidingInfo) list -> Tycon -> bool
 
diff --git a/src/Compiler/TypedTree/TypedTreePickle.fs b/src/Compiler/TypedTree/TypedTreePickle.fs
index f2fd9887772..fe71dc1429f 100644
--- a/src/Compiler/TypedTree/TypedTreePickle.fs
+++ b/src/Compiler/TypedTree/TypedTreePickle.fs
@@ -1777,7 +1777,7 @@ let p_istype x st =
     | ModuleOrType           -> p_byte 1 st
     | Namespace _            -> p_byte 2 st
 
-let p_cpath (CompPath(a, b)) st =
+let p_cpath (CompPath(a, _, b)) st =
     p_tup2 p_ILScopeRef (p_list (p_tup2 p_string p_istype)) (a, b) st
 
 let u_ranges st = u_option (u_tup2 u_range u_range) st
@@ -1792,7 +1792,7 @@ let u_istype st =
 
 let u_cpath st =
     let a, b = u_tup2 u_ILScopeRef (u_list (u_tup2 u_string u_istype)) st 
-    CompPath(a, b)
+    CompPath(a, SyntaxAccess.Unknown, b)
 
 let rec p_tycon_repr x st =
     // The leading "p_byte 1" and "p_byte 0" come from the F# 2.0 format, which used an option value at this point.
diff --git a/src/Compiler/lex.fsl b/src/Compiler/lex.fsl
index 958c2fa51ea..1e48cc8d0a2 100644
--- a/src/Compiler/lex.fsl
+++ b/src/Compiler/lex.fsl
@@ -120,7 +120,7 @@ let checkExprGreaterColonOp (lexbuf:UnicodeLexing.Lexbuf) =
 let unexpectedChar lexbuf =
     LEX_FAILURE (FSComp.SR.lexUnexpectedChar(lexeme lexbuf))
 
-let startString args (lexbuf: UnicodeLexing.Lexbuf) altStartForStringEnd =
+let startString args (lexbuf: UnicodeLexing.Lexbuf) =
     let buf = ByteBuffer.Create StringCapacity
     let m = lexbuf.LexemeRange
     let startp = lexbuf.StartPos
@@ -160,7 +160,7 @@ let startString args (lexbuf: UnicodeLexing.Lexbuf) altStartForStringEnd =
                     if isPart then
                         INTERP_STRING_PART (s, cont)
                     else
-                        INTERP_STRING_END (s, altStartForStringEnd, cont)
+                        INTERP_STRING_END (s, cont)
             else
                 let s = Lexhelp.stringBufferAsString buf
                 let synStringKind =
@@ -587,7 +587,7 @@ rule token (args: LexArgs) (skip: bool) = parse
        else mlOnly m args skip lexbuf }
 
  | '"'
-     { let buf, fin, m = startString args lexbuf None
+     { let buf, fin, m = startString args lexbuf
 
        // Single quote in triple quote ok, others disallowed
        match args.stringNest with
@@ -600,7 +600,7 @@ rule token (args: LexArgs) (skip: bool) = parse
        else singleQuoteString (buf, fin, m, LexerStringKind.String, args) skip lexbuf }
 
  | '$' '"' '"' '"'
-     { let buf, fin, m = startString args lexbuf None
+     { let buf, fin, m = startString args lexbuf
 
        // Single quote in triple quote ok, others disallowed
        match args.stringNest with
@@ -612,7 +612,7 @@ rule token (args: LexArgs) (skip: bool) = parse
        else tripleQuoteString (buf, fin, m, LexerStringKind.InterpolatedStringFirst, args) skip lexbuf }
 
  | ('$'+) '"' '"' '"'
-     { let buf, fin, m = startString args lexbuf None
+     { let buf, fin, m = startString args lexbuf
 
        if lexbuf.SupportsFeature LanguageFeature.ExtendedStringInterpolation then
            // Single quote in triple quote ok, others disallowed
@@ -635,7 +635,7 @@ rule token (args: LexArgs) (skip: bool) = parse
      }
 
  | '$' '"'
-     { let buf,fin,m = startString args lexbuf None
+     { let buf,fin,m = startString args lexbuf
 
        // Single quote in triple quote ok, others disallowed
        match args.stringNest with
@@ -649,7 +649,7 @@ rule token (args: LexArgs) (skip: bool) = parse
            singleQuoteString (buf, fin, m, LexerStringKind.InterpolatedStringFirst, args) skip lexbuf }
 
  | '"' '"' '"'
-     { let buf, fin, m = startString args lexbuf None
+     { let buf, fin, m = startString args lexbuf
 
        args.interpolationDelimiterLength <- 0
 
@@ -664,7 +664,7 @@ rule token (args: LexArgs) (skip: bool) = parse
            tripleQuoteString (buf, fin, m, LexerStringKind.String, args) skip lexbuf }
 
  | '@' '"'
-     { let buf, fin, m = startString args lexbuf None
+     { let buf, fin, m = startString args lexbuf
 
        // Single quote in triple quote ok, others disallowed
        match args.stringNest with
@@ -679,7 +679,7 @@ rule token (args: LexArgs) (skip: bool) = parse
            verbatimString (buf, fin, m, LexerStringKind.String, args) skip lexbuf }
 
  | ("$@" | "@$") '"'
-     { let buf, fin, m = startString args lexbuf None
+     { let buf, fin, m = startString args lexbuf
 
        // Single quote in triple quote ok, others disallowed
        match args.stringNest with
@@ -914,7 +914,11 @@ rule token (args: LexArgs) (skip: bool) = parse
            token args skip lexbuf
        | (1, style, _, altR, _r) :: rest ->
            args.stringNest <- rest
-           let buf, fin, m = startString args lexbuf altR
+           altR
+           |> Option.iter (fun r ->
+               let n = r.StartColumn - lexbuf.StartPos.Column 
+               lexbuf.StartPos <- lexbuf.StartPos.ShiftColumnBy(n)) 
+           let buf, fin, m = startString args lexbuf
            if not skip then
                STRING_TEXT (LexCont.String(args.ifdefStack, args.stringNest, style, LexerStringKind.InterpolatedStringPart, args.interpolationDelimiterLength, m))
            else
diff --git a/src/Compiler/pars.fsy b/src/Compiler/pars.fsy
index 36e8d0838c8..4080fc7ec8b 100644
--- a/src/Compiler/pars.fsy
+++ b/src/Compiler/pars.fsy
@@ -38,7 +38,7 @@ let parse_error_rich = Some(fun (ctxt: ParseErrorContext<_>) ->
 %token <string * SynStringKind * ParseHelpers.LexerContinuation> INTERP_STRING_BEGIN_END
 %token <string * SynStringKind * ParseHelpers.LexerContinuation> INTERP_STRING_BEGIN_PART
 %token <string * ParseHelpers.LexerContinuation> INTERP_STRING_PART
-%token <string * range option * ParseHelpers.LexerContinuation> INTERP_STRING_END
+%token <string * ParseHelpers.LexerContinuation> INTERP_STRING_END
 %token <ParseHelpers.LexerContinuation> LBRACE RBRACE
 
 %token <string * string> KEYWORD_STRING // Like __SOURCE_DIRECTORY__
@@ -6774,14 +6774,7 @@ interpolatedStringFill:
 
 interpolatedStringParts:
   | INTERP_STRING_END
-     {
-       let (s, altStart, _) = $1
-       let mOrig = rhs parseState 1
-       let m =
-           match altStart with
-           | Some r -> unionRanges r mOrig
-           | None -> mOrig
-       [ SynInterpolatedStringPart.String(s, m) ] }
+     { [ SynInterpolatedStringPart.String(fst $1, rhs parseState 1) ] }
 
   | INTERP_STRING_PART interpolatedStringFill interpolatedStringParts
      { SynInterpolatedStringPart.String(fst $1, rhs parseState 1) :: SynInterpolatedStringPart.FillExpr $2 :: $3 }
diff --git a/src/Compiler/xlf/FSComp.txt.cs.xlf b/src/Compiler/xlf/FSComp.txt.cs.xlf
index d4142d783fa..c46e652979d 100644
--- a/src/Compiler/xlf/FSComp.txt.cs.xlf
+++ b/src/Compiler/xlf/FSComp.txt.cs.xlf
@@ -297,6 +297,11 @@
         <target state="new">Enforce AttributeTargets on functions</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureEnforceAttributeTargetsUnionCaseDeclarations">
+        <source>Enforce AttributeTargets on union case declarations</source>
+        <target state="new">Enforce AttributeTargets on union case declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
         <target state="translated">Vyvolá chyby pro přepsání jiných než virtuálních členů</target>
@@ -827,6 +832,11 @@
         <target state="translated">Název výstupního souboru pdb se nemůže shodovat s výstupním názvem souboru sestavení pomocí --pdb:filename.pdb.</target>
         <note />
       </trans-unit>
+      <trans-unit id="optsRealsig">
+        <source>Generate assembly with IL visibility that matches the source code visibility</source>
+        <target state="new">Generate assembly with IL visibility that matches the source code visibility</target>
+        <note />
+      </trans-unit>
       <trans-unit id="optsRefOnly">
         <source>Produce a reference assembly, instead of a full assembly, as the primary output</source>
         <target state="translated">Vytvoří referenční sestavení místo úplného sestavení jako primární výstup.</target>
@@ -6217,11 +6227,6 @@
         <target state="translated">Hodnota {0} má označení inline, ale není svázaná s prostředím optimalizace.</target>
         <note />
       </trans-unit>
-      <trans-unit id="optLocalValueNotFoundDuringOptimization">
-        <source>Local value {0} not found during optimization</source>
-        <target state="translated">Lokální hodnota {0} se během optimalizace nenašla.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="optValueMarkedInlineHasUnexpectedValue">
         <source>A value marked as 'inline' has an unexpected value</source>
         <target state="translated">Hodnota s označením inline má neočekávanou hodnotu.</target>
diff --git a/src/Compiler/xlf/FSComp.txt.de.xlf b/src/Compiler/xlf/FSComp.txt.de.xlf
index fa0904ef50f..56f7493d1d1 100644
--- a/src/Compiler/xlf/FSComp.txt.de.xlf
+++ b/src/Compiler/xlf/FSComp.txt.de.xlf
@@ -297,6 +297,11 @@
         <target state="new">Enforce AttributeTargets on functions</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureEnforceAttributeTargetsUnionCaseDeclarations">
+        <source>Enforce AttributeTargets on union case declarations</source>
+        <target state="new">Enforce AttributeTargets on union case declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
         <target state="translated">Löst Fehler für Außerkraftsetzungen nicht virtueller Member aus.</target>
@@ -827,6 +832,11 @@
         <target state="translated">Der Name der PDB-Ausgabedatei kann nicht mit dem Ausgabedateinamen für den Build übereinstimmen, verwenden Sie --pdb:filename.pdb</target>
         <note />
       </trans-unit>
+      <trans-unit id="optsRealsig">
+        <source>Generate assembly with IL visibility that matches the source code visibility</source>
+        <target state="new">Generate assembly with IL visibility that matches the source code visibility</target>
+        <note />
+      </trans-unit>
       <trans-unit id="optsRefOnly">
         <source>Produce a reference assembly, instead of a full assembly, as the primary output</source>
         <target state="translated">Erstellen einer Referenzassembly anstelle einer vollständigen Assembly als primäre Ausgabe</target>
@@ -6217,11 +6227,6 @@
         <target state="translated">Der Wert "{0}" war als inline markiert, aber nicht in der Optimierungsumgebung gebunden.</target>
         <note />
       </trans-unit>
-      <trans-unit id="optLocalValueNotFoundDuringOptimization">
-        <source>Local value {0} not found during optimization</source>
-        <target state="translated">Der lokale Wert "{0}" wurde während der Optimierung nicht gefunden.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="optValueMarkedInlineHasUnexpectedValue">
         <source>A value marked as 'inline' has an unexpected value</source>
         <target state="translated">Ein als "inline" markierter Wert hat einen unerwarteten Wert.</target>
diff --git a/src/Compiler/xlf/FSComp.txt.es.xlf b/src/Compiler/xlf/FSComp.txt.es.xlf
index 2d5ada63574..a35a6bce598 100644
--- a/src/Compiler/xlf/FSComp.txt.es.xlf
+++ b/src/Compiler/xlf/FSComp.txt.es.xlf
@@ -297,6 +297,11 @@
         <target state="new">Enforce AttributeTargets on functions</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureEnforceAttributeTargetsUnionCaseDeclarations">
+        <source>Enforce AttributeTargets on union case declarations</source>
+        <target state="new">Enforce AttributeTargets on union case declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
         <target state="translated">Genera errores para invalidaciones de miembros no virtuales</target>
@@ -827,6 +832,11 @@
         <target state="translated">El nombre del archivo de salida pdb no puede coincidir con el nombre de archivo de salida de compilación. Use --pdb:filename.pdb</target>
         <note />
       </trans-unit>
+      <trans-unit id="optsRealsig">
+        <source>Generate assembly with IL visibility that matches the source code visibility</source>
+        <target state="new">Generate assembly with IL visibility that matches the source code visibility</target>
+        <note />
+      </trans-unit>
       <trans-unit id="optsRefOnly">
         <source>Produce a reference assembly, instead of a full assembly, as the primary output</source>
         <target state="translated">Generar un ensamblado de referencia, en lugar de un ensamblado completo, como salida principal</target>
@@ -6217,11 +6227,6 @@
         <target state="translated">El valor '{0}' estaba marcado como inline pero no estaba enlazado en el entorno de optimización.</target>
         <note />
       </trans-unit>
-      <trans-unit id="optLocalValueNotFoundDuringOptimization">
-        <source>Local value {0} not found during optimization</source>
-        <target state="translated">No se encontró el valor local {0} durante la optimización.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="optValueMarkedInlineHasUnexpectedValue">
         <source>A value marked as 'inline' has an unexpected value</source>
         <target state="translated">Un valor marcado como 'inline' tiene un valor inesperado.</target>
diff --git a/src/Compiler/xlf/FSComp.txt.fr.xlf b/src/Compiler/xlf/FSComp.txt.fr.xlf
index da3c6f4b9b6..aeeb53ac93d 100644
--- a/src/Compiler/xlf/FSComp.txt.fr.xlf
+++ b/src/Compiler/xlf/FSComp.txt.fr.xlf
@@ -297,6 +297,11 @@
         <target state="new">Enforce AttributeTargets on functions</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureEnforceAttributeTargetsUnionCaseDeclarations">
+        <source>Enforce AttributeTargets on union case declarations</source>
+        <target state="new">Enforce AttributeTargets on union case declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
         <target state="translated">Déclenche des erreurs pour les remplacements de membres non virtuels</target>
@@ -827,6 +832,11 @@
         <target state="translated">Le nom du fichier de sortie pdb ne peut pas correspondre au nom de fichier de sortie de build utilisé --pdb:filename.pdb.</target>
         <note />
       </trans-unit>
+      <trans-unit id="optsRealsig">
+        <source>Generate assembly with IL visibility that matches the source code visibility</source>
+        <target state="new">Generate assembly with IL visibility that matches the source code visibility</target>
+        <note />
+      </trans-unit>
       <trans-unit id="optsRefOnly">
         <source>Produce a reference assembly, instead of a full assembly, as the primary output</source>
         <target state="translated">Produire un assembly de référence, au lieu d’un assembly complet, en tant que sortie principale</target>
@@ -6217,11 +6227,6 @@
         <target state="translated">La valeur '{0}' a été marquée comme inline mais n'a pas été liée dans l'environnement d'optimisation</target>
         <note />
       </trans-unit>
-      <trans-unit id="optLocalValueNotFoundDuringOptimization">
-        <source>Local value {0} not found during optimization</source>
-        <target state="translated">Valeur locale {0} introuvable durant l'optimisation</target>
-        <note />
-      </trans-unit>
       <trans-unit id="optValueMarkedInlineHasUnexpectedValue">
         <source>A value marked as 'inline' has an unexpected value</source>
         <target state="translated">Une valeur marquée comme 'inline' a une valeur inattendue</target>
diff --git a/src/Compiler/xlf/FSComp.txt.it.xlf b/src/Compiler/xlf/FSComp.txt.it.xlf
index 010e34a81a2..390160ee95e 100644
--- a/src/Compiler/xlf/FSComp.txt.it.xlf
+++ b/src/Compiler/xlf/FSComp.txt.it.xlf
@@ -297,6 +297,11 @@
         <target state="new">Enforce AttributeTargets on functions</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureEnforceAttributeTargetsUnionCaseDeclarations">
+        <source>Enforce AttributeTargets on union case declarations</source>
+        <target state="new">Enforce AttributeTargets on union case declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
         <target state="translated">Genera errori per gli override dei membri non virtuali</target>
@@ -827,6 +832,11 @@
         <target state="translated">Il nome del file di output pdb non può corrispondere all’uso del nome file di output della compilazione --pdb:filename.pdb</target>
         <note />
       </trans-unit>
+      <trans-unit id="optsRealsig">
+        <source>Generate assembly with IL visibility that matches the source code visibility</source>
+        <target state="new">Generate assembly with IL visibility that matches the source code visibility</target>
+        <note />
+      </trans-unit>
       <trans-unit id="optsRefOnly">
         <source>Produce a reference assembly, instead of a full assembly, as the primary output</source>
         <target state="translated">Produce un assembly di riferimento, anziché un assembly completo, come output primario</target>
@@ -6217,11 +6227,6 @@
         <target state="translated">Il valore '{0}' è stato contrassegnato come inline, tuttavia non è stato associato nell'ambiente di ottimizzazione</target>
         <note />
       </trans-unit>
-      <trans-unit id="optLocalValueNotFoundDuringOptimization">
-        <source>Local value {0} not found during optimization</source>
-        <target state="translated">Valore locale {0} non trovato durante l'ottimizzazione</target>
-        <note />
-      </trans-unit>
       <trans-unit id="optValueMarkedInlineHasUnexpectedValue">
         <source>A value marked as 'inline' has an unexpected value</source>
         <target state="translated">Valore imprevisto contrassegnato come 'inline'</target>
diff --git a/src/Compiler/xlf/FSComp.txt.ja.xlf b/src/Compiler/xlf/FSComp.txt.ja.xlf
index 8a92ac2ea9e..e57dac6f312 100644
--- a/src/Compiler/xlf/FSComp.txt.ja.xlf
+++ b/src/Compiler/xlf/FSComp.txt.ja.xlf
@@ -297,6 +297,11 @@
         <target state="new">Enforce AttributeTargets on functions</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureEnforceAttributeTargetsUnionCaseDeclarations">
+        <source>Enforce AttributeTargets on union case declarations</source>
+        <target state="new">Enforce AttributeTargets on union case declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
         <target state="translated">仮想メンバー以外のオーバーライドに対してエラーを発生させます</target>
@@ -827,6 +832,11 @@
         <target state="translated">PDB 出力ファイル名がビルド出力ファイル名と一致しません - --pdb:filename.pdb を使用してください</target>
         <note />
       </trans-unit>
+      <trans-unit id="optsRealsig">
+        <source>Generate assembly with IL visibility that matches the source code visibility</source>
+        <target state="new">Generate assembly with IL visibility that matches the source code visibility</target>
+        <note />
+      </trans-unit>
       <trans-unit id="optsRefOnly">
         <source>Produce a reference assembly, instead of a full assembly, as the primary output</source>
         <target state="translated">完全なアセンブリではなく、参照アセンブリをプライマリ出力として生成します</target>
@@ -6217,11 +6227,6 @@
         <target state="translated">値 '{0}' は 'inline' とマークされましたが、最適化環境ではバインドされません</target>
         <note />
       </trans-unit>
-      <trans-unit id="optLocalValueNotFoundDuringOptimization">
-        <source>Local value {0} not found during optimization</source>
-        <target state="translated">最適化中にローカルの値 {0} が見つかりませんでした</target>
-        <note />
-      </trans-unit>
       <trans-unit id="optValueMarkedInlineHasUnexpectedValue">
         <source>A value marked as 'inline' has an unexpected value</source>
         <target state="translated">'inline' とマークされた値に予期しない値が含まれます</target>
diff --git a/src/Compiler/xlf/FSComp.txt.ko.xlf b/src/Compiler/xlf/FSComp.txt.ko.xlf
index 51778bd4145..2d6a4e5e22b 100644
--- a/src/Compiler/xlf/FSComp.txt.ko.xlf
+++ b/src/Compiler/xlf/FSComp.txt.ko.xlf
@@ -297,6 +297,11 @@
         <target state="new">Enforce AttributeTargets on functions</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureEnforceAttributeTargetsUnionCaseDeclarations">
+        <source>Enforce AttributeTargets on union case declarations</source>
+        <target state="new">Enforce AttributeTargets on union case declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
         <target state="translated">비가상 멤버 재정의에 대한 오류 발생</target>
@@ -827,6 +832,11 @@
         <target state="translated">pdb 출력 파일 이름은 빌드 출력 파일 이름 사용 --pdb:filename.pdb와 일치할 수 없습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="optsRealsig">
+        <source>Generate assembly with IL visibility that matches the source code visibility</source>
+        <target state="new">Generate assembly with IL visibility that matches the source code visibility</target>
+        <note />
+      </trans-unit>
       <trans-unit id="optsRefOnly">
         <source>Produce a reference assembly, instead of a full assembly, as the primary output</source>
         <target state="translated">주 출력으로 전체 어셈블리 대신 참조 어셈블리를 생성합니다.</target>
@@ -6217,11 +6227,6 @@
         <target state="translated">값 '{0}'이(가) inline으로 표시되었지만 최적화 환경에 바인딩되지 않았습니다.</target>
         <note />
       </trans-unit>
-      <trans-unit id="optLocalValueNotFoundDuringOptimization">
-        <source>Local value {0} not found during optimization</source>
-        <target state="translated">최적화하는 동안 로컬 값 {0}을(를) 찾을 수 없습니다.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="optValueMarkedInlineHasUnexpectedValue">
         <source>A value marked as 'inline' has an unexpected value</source>
         <target state="translated">'inline'으로 표시된 값에 예기치 않은 값이 있습니다.</target>
diff --git a/src/Compiler/xlf/FSComp.txt.pl.xlf b/src/Compiler/xlf/FSComp.txt.pl.xlf
index a8a3f05ba9a..db56cd3ba49 100644
--- a/src/Compiler/xlf/FSComp.txt.pl.xlf
+++ b/src/Compiler/xlf/FSComp.txt.pl.xlf
@@ -297,6 +297,11 @@
         <target state="new">Enforce AttributeTargets on functions</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureEnforceAttributeTargetsUnionCaseDeclarations">
+        <source>Enforce AttributeTargets on union case declarations</source>
+        <target state="new">Enforce AttributeTargets on union case declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
         <target state="translated">Zgłasza błędy w przypadku przesłonięć elementów innych niż wirtualne</target>
@@ -827,6 +832,11 @@
         <target state="translated">Nazwa pliku wyjściowego pdb nie może być zgodna z nazwą pliku wyjściowego kompilacji, użyj parametru --pdb:filename.pdb</target>
         <note />
       </trans-unit>
+      <trans-unit id="optsRealsig">
+        <source>Generate assembly with IL visibility that matches the source code visibility</source>
+        <target state="new">Generate assembly with IL visibility that matches the source code visibility</target>
+        <note />
+      </trans-unit>
       <trans-unit id="optsRefOnly">
         <source>Produce a reference assembly, instead of a full assembly, as the primary output</source>
         <target state="translated">Utwórz zestaw odwołania zamiast pełnego zestawu jako podstawowe dane wyjściowe</target>
@@ -6217,11 +6227,6 @@
         <target state="translated">Wartość „{0}” została oznaczona jako śródwierszowa, ale nie powiązano jej w środowisku optymalizacji</target>
         <note />
       </trans-unit>
-      <trans-unit id="optLocalValueNotFoundDuringOptimization">
-        <source>Local value {0} not found during optimization</source>
-        <target state="translated">Nie znaleziono wartości lokalnej {0} podczas optymalizacji</target>
-        <note />
-      </trans-unit>
       <trans-unit id="optValueMarkedInlineHasUnexpectedValue">
         <source>A value marked as 'inline' has an unexpected value</source>
         <target state="translated">Wartość oznaczona jako „inline” ma nieoczekiwaną wartość</target>
diff --git a/src/Compiler/xlf/FSComp.txt.pt-BR.xlf b/src/Compiler/xlf/FSComp.txt.pt-BR.xlf
index 1f62f9a3d04..7566fb49ae1 100644
--- a/src/Compiler/xlf/FSComp.txt.pt-BR.xlf
+++ b/src/Compiler/xlf/FSComp.txt.pt-BR.xlf
@@ -297,6 +297,11 @@
         <target state="new">Enforce AttributeTargets on functions</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureEnforceAttributeTargetsUnionCaseDeclarations">
+        <source>Enforce AttributeTargets on union case declarations</source>
+        <target state="new">Enforce AttributeTargets on union case declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
         <target state="translated">Gera erros para substituições de membros não virtuais</target>
@@ -827,6 +832,11 @@
         <target state="translated">O nome do arquivo de saída pdb não pode corresponder ao nome do arquivo de saída do build. Use --pdb:filename.pdb</target>
         <note />
       </trans-unit>
+      <trans-unit id="optsRealsig">
+        <source>Generate assembly with IL visibility that matches the source code visibility</source>
+        <target state="new">Generate assembly with IL visibility that matches the source code visibility</target>
+        <note />
+      </trans-unit>
       <trans-unit id="optsRefOnly">
         <source>Produce a reference assembly, instead of a full assembly, as the primary output</source>
         <target state="translated">Produzir um assembly de referência, em vez de um assembly completo, como a saída primária</target>
@@ -6217,11 +6227,6 @@
         <target state="translated">O valor '{0}' foi marcado como embutido, mas não está associado no ambiente de otimização</target>
         <note />
       </trans-unit>
-      <trans-unit id="optLocalValueNotFoundDuringOptimization">
-        <source>Local value {0} not found during optimization</source>
-        <target state="translated">O valor local {0} não foi encontrado durante a otimização</target>
-        <note />
-      </trans-unit>
       <trans-unit id="optValueMarkedInlineHasUnexpectedValue">
         <source>A value marked as 'inline' has an unexpected value</source>
         <target state="translated">Um valor marcado como 'embutido' possui um valor inesperado</target>
diff --git a/src/Compiler/xlf/FSComp.txt.ru.xlf b/src/Compiler/xlf/FSComp.txt.ru.xlf
index 64ce92b6125..90c39f565ee 100644
--- a/src/Compiler/xlf/FSComp.txt.ru.xlf
+++ b/src/Compiler/xlf/FSComp.txt.ru.xlf
@@ -297,6 +297,11 @@
         <target state="new">Enforce AttributeTargets on functions</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureEnforceAttributeTargetsUnionCaseDeclarations">
+        <source>Enforce AttributeTargets on union case declarations</source>
+        <target state="new">Enforce AttributeTargets on union case declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
         <target state="translated">Вызывает ошибки при переопределениях невиртуальных элементов</target>
@@ -827,6 +832,11 @@
         <target state="translated">Имя выходного файла pdb не может совпадать с именем выходного файла сборки. Используйте --pdb:filename.pdb</target>
         <note />
       </trans-unit>
+      <trans-unit id="optsRealsig">
+        <source>Generate assembly with IL visibility that matches the source code visibility</source>
+        <target state="new">Generate assembly with IL visibility that matches the source code visibility</target>
+        <note />
+      </trans-unit>
       <trans-unit id="optsRefOnly">
         <source>Produce a reference assembly, instead of a full assembly, as the primary output</source>
         <target state="translated">Создайте базовую сборку вместо полной сборки в качестве основных выходных данных</target>
@@ -6217,11 +6227,6 @@
         <target state="translated">Значение "{0}" отмечено как "inline", однако не было привязано в среде оптимизации</target>
         <note />
       </trans-unit>
-      <trans-unit id="optLocalValueNotFoundDuringOptimization">
-        <source>Local value {0} not found during optimization</source>
-        <target state="translated">В процессе оптимизации не найдено локальное значение {0}</target>
-        <note />
-      </trans-unit>
       <trans-unit id="optValueMarkedInlineHasUnexpectedValue">
         <source>A value marked as 'inline' has an unexpected value</source>
         <target state="translated">Недопустимое значение для значения, отмеченного как "inline"</target>
diff --git a/src/Compiler/xlf/FSComp.txt.tr.xlf b/src/Compiler/xlf/FSComp.txt.tr.xlf
index d77dfd672ec..496bc35ef95 100644
--- a/src/Compiler/xlf/FSComp.txt.tr.xlf
+++ b/src/Compiler/xlf/FSComp.txt.tr.xlf
@@ -297,6 +297,11 @@
         <target state="new">Enforce AttributeTargets on functions</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureEnforceAttributeTargetsUnionCaseDeclarations">
+        <source>Enforce AttributeTargets on union case declarations</source>
+        <target state="new">Enforce AttributeTargets on union case declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
         <target state="translated">Sanal olmayan üyelerde geçersiz kılmalar için hatalar oluştur</target>
@@ -827,6 +832,11 @@
         <target state="translated">pdb çıkış dosyası adı, derleme çıkış dosya adı kullanımı --pdb:filename.pdb ile eşleşmiyor</target>
         <note />
       </trans-unit>
+      <trans-unit id="optsRealsig">
+        <source>Generate assembly with IL visibility that matches the source code visibility</source>
+        <target state="new">Generate assembly with IL visibility that matches the source code visibility</target>
+        <note />
+      </trans-unit>
       <trans-unit id="optsRefOnly">
         <source>Produce a reference assembly, instead of a full assembly, as the primary output</source>
         <target state="translated">Birincil çıktı olarak, tam bir derleme yerine, başvuru bütünleştirilmiş kodu üretin</target>
@@ -6217,11 +6227,6 @@
         <target state="translated">'{0}' değeri satır içi olarak işaretlenmiş ancak iyileştirme ortamında bağlanmamış</target>
         <note />
       </trans-unit>
-      <trans-unit id="optLocalValueNotFoundDuringOptimization">
-        <source>Local value {0} not found during optimization</source>
-        <target state="translated">İyileştirme sırasında {0} yerel değeri bulunamadı</target>
-        <note />
-      </trans-unit>
       <trans-unit id="optValueMarkedInlineHasUnexpectedValue">
         <source>A value marked as 'inline' has an unexpected value</source>
         <target state="translated">'inline' olarak işaretlenmiş değerde beklenmeyen bir değer var</target>
diff --git a/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf b/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf
index 5393d25202a..94bd2ea062c 100644
--- a/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf
+++ b/src/Compiler/xlf/FSComp.txt.zh-Hans.xlf
@@ -297,6 +297,11 @@
         <target state="new">Enforce AttributeTargets on functions</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureEnforceAttributeTargetsUnionCaseDeclarations">
+        <source>Enforce AttributeTargets on union case declarations</source>
+        <target state="new">Enforce AttributeTargets on union case declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
         <target state="translated">引发非虚拟成员替代的错误</target>
@@ -827,6 +832,11 @@
         <target state="translated">pdb 输出文件名不能与生成输出文件名 use --pdb: filename.pdb 匹配</target>
         <note />
       </trans-unit>
+      <trans-unit id="optsRealsig">
+        <source>Generate assembly with IL visibility that matches the source code visibility</source>
+        <target state="new">Generate assembly with IL visibility that matches the source code visibility</target>
+        <note />
+      </trans-unit>
       <trans-unit id="optsRefOnly">
         <source>Produce a reference assembly, instead of a full assembly, as the primary output</source>
         <target state="translated">生成引用程序集而不是完整程序集作为主输出</target>
@@ -6217,11 +6227,6 @@
         <target state="translated">值“{0}”已标记为“inline”，但其未在优化环境中绑定</target>
         <note />
       </trans-unit>
-      <trans-unit id="optLocalValueNotFoundDuringOptimization">
-        <source>Local value {0} not found during optimization</source>
-        <target state="translated">优化过程中未找到本地值 {0}</target>
-        <note />
-      </trans-unit>
       <trans-unit id="optValueMarkedInlineHasUnexpectedValue">
         <source>A value marked as 'inline' has an unexpected value</source>
         <target state="translated">标记为“inline”的值具有意外的值</target>
diff --git a/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf b/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf
index f75fc155fde..9334199ba0f 100644
--- a/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf
+++ b/src/Compiler/xlf/FSComp.txt.zh-Hant.xlf
@@ -297,6 +297,11 @@
         <target state="new">Enforce AttributeTargets on functions</target>
         <note />
       </trans-unit>
+      <trans-unit id="featureEnforceAttributeTargetsUnionCaseDeclarations">
+        <source>Enforce AttributeTargets on union case declarations</source>
+        <target state="new">Enforce AttributeTargets on union case declarations</target>
+        <note />
+      </trans-unit>
       <trans-unit id="featureErrorForNonVirtualMembersOverrides">
         <source>Raises errors for non-virtual members overrides</source>
         <target state="translated">引發非虛擬成員覆寫的錯誤</target>
@@ -827,6 +832,11 @@
         <target state="translated">pdb 輸出檔案名與使用 --pdb:filename.pdb 的建置輸出檔案名不相符</target>
         <note />
       </trans-unit>
+      <trans-unit id="optsRealsig">
+        <source>Generate assembly with IL visibility that matches the source code visibility</source>
+        <target state="new">Generate assembly with IL visibility that matches the source code visibility</target>
+        <note />
+      </trans-unit>
       <trans-unit id="optsRefOnly">
         <source>Produce a reference assembly, instead of a full assembly, as the primary output</source>
         <target state="translated">產生參考組件，而非完整組件作為主要輸出</target>
@@ -6217,11 +6227,6 @@
         <target state="translated">值 '{0}' 已標記為內嵌，但是未在最佳化環境中繫結</target>
         <note />
       </trans-unit>
-      <trans-unit id="optLocalValueNotFoundDuringOptimization">
-        <source>Local value {0} not found during optimization</source>
-        <target state="translated">最佳化期間找不到區域數值 {0}</target>
-        <note />
-      </trans-unit>
       <trans-unit id="optValueMarkedInlineHasUnexpectedValue">
         <source>A value marked as 'inline' has an unexpected value</source>
         <target state="translated">標記為 'inline' 的值有未預期的值</target>
diff --git a/src/FSharp.Core/FSharp.Core.fsproj b/src/FSharp.Core/FSharp.Core.fsproj
index cf267f6f914..c2ad1d456a3 100644
--- a/src/FSharp.Core/FSharp.Core.fsproj
+++ b/src/FSharp.Core/FSharp.Core.fsproj
@@ -25,10 +25,11 @@
     <!-- Turn off 3513: resumable code invocation' - expected for resumable code combinators -->
     <OtherFlags>$(OtherFlags) --nowarn:3513</OtherFlags>
     <OtherFlags>$(OtherFlags) --compiling-fslib --compiling-fslib-40 --maxerrors:100 --extraoptimizationloops:1</OtherFlags>
+    <!-- .FSharp.Core always uses the old style initialization mechanism because of SQL CLR requirements -->
+    <OtherFlags Condition="'$(Configuration)' != 'Proto'">$(OtherFlags) --realsig-</OtherFlags>
     <!-- .tail annotations always emitted for this binary, even in debug mode -->
     <Tailcalls>true</Tailcalls>
     <NGenBinary>true</NGenBinary>
-
     <PreRelease>true</PreRelease>
     <PackageId>FSharp.Core</PackageId>
     <PackageVersionPrefix>$(FSCorePackageVersion)</PackageVersionPrefix>
diff --git a/src/FSharp.Core/array.fs b/src/FSharp.Core/array.fs
index a2797467b7c..344d7e3e7cf 100644
--- a/src/FSharp.Core/array.fs
+++ b/src/FSharp.Core/array.fs
@@ -2,6 +2,8 @@
 
 namespace Microsoft.FSharp.Collections
 
+//#nowarn "1118" // 'Make' marked 'inline', perhaps because a recursive value was marked 'inline'
+
 open System
 open System.Diagnostics
 open System.Collections.Generic
@@ -2081,10 +2083,10 @@ module Array =
 
         // The following two parameters were benchmarked and found to be optimal.
         // Benchmark was run using: 11th Gen Intel Core i9-11950H 2.60GHz, 1 CPU, 16 logical and 8 physical cores
-        let private maxPartitions = Environment.ProcessorCount // The maximum number of partitions to use
-        let private minChunkSize = 256 // The minimum size of a chunk to be sorted in parallel
+        let maxPartitions = Environment.ProcessorCount // The maximum number of partitions to use
+        let minChunkSize = 256 // The minimum size of a chunk to be sorted in parallel
 
-        let private createPartitionsUpToWithMinChunkSize maxIdxExclusive minChunkSize (array: 'T array) =
+        let createPartitionsUpToWithMinChunkSize maxIdxExclusive minChunkSize (array: 'T array) =
             [|
                 let chunkSize =
                     match maxIdxExclusive with
@@ -2101,7 +2103,7 @@ module Array =
                 yield new ArraySegment<'T>(array, offset, maxIdxExclusive - offset)
             |]
 
-        let private createPartitionsUpTo maxIdxExclusive (array: 'T array) =
+        let createPartitionsUpTo maxIdxExclusive (array: 'T array) =
             createPartitionsUpToWithMinChunkSize maxIdxExclusive minChunkSize array
 
         (* This function is there also as a support vehicle for other aggregations. 
diff --git a/src/FSharp.Core/fslib-extra-pervasives.fs b/src/FSharp.Core/fslib-extra-pervasives.fs
index def5d42c2e5..b62d5b16eb8 100644
--- a/src/FSharp.Core/fslib-extra-pervasives.fs
+++ b/src/FSharp.Core/fslib-extra-pervasives.fs
@@ -13,6 +13,7 @@ module ExtraTopLevelOperators =
     open Microsoft.FSharp.Core.Operators
     open Microsoft.FSharp.Collections
     open Microsoft.FSharp.Control
+    open Microsoft.FSharp.Linq
     open Microsoft.FSharp.Primitives.Basics
     open Microsoft.FSharp.Core.CompilerServices
 
@@ -334,7 +335,7 @@ module ExtraTopLevelOperators =
     let (|Lazy|) (input: Lazy<_>) =
         input.Force()
 
-    let query = Microsoft.FSharp.Linq.QueryBuilder()
+    let query = QueryBuilder()
 
 namespace Microsoft.FSharp.Core.CompilerServices
 
diff --git a/src/FSharp.Core/fslib-extra-pervasives.fsi b/src/FSharp.Core/fslib-extra-pervasives.fsi
index bd4bf0ee8b5..ffd6f6f6a00 100644
--- a/src/FSharp.Core/fslib-extra-pervasives.fsi
+++ b/src/FSharp.Core/fslib-extra-pervasives.fsi
@@ -13,6 +13,8 @@ module ExtraTopLevelOperators =
     open Microsoft.FSharp.Core
     open Microsoft.FSharp.Control
     open Microsoft.FSharp.Collections
+    open Microsoft.FSharp.Control
+    open Microsoft.FSharp.Linq
     open Microsoft.FSharp.Quotations
 
     /// <summary>Print to <c>stdout</c> using the given format.</summary>
@@ -129,7 +131,7 @@ module ExtraTopLevelOperators =
     /// </code>
     /// </example>
     [<CompiledName("DefaultAsyncBuilder")>]
-    val async: Microsoft.FSharp.Control.AsyncBuilder  
+    val async: AsyncBuilder
 
     /// <summary>Converts the argument to 32-bit float.</summary>
     ///
@@ -358,7 +360,7 @@ module ExtraTopLevelOperators =
     /// </code>
     /// Evaluates to <c>[4; 4; 12; 12]</c>.
     /// </example>
-    val query: Microsoft.FSharp.Linq.QueryBuilder
+    val query: QueryBuilder
 
 namespace Microsoft.FSharp.Core.CompilerServices
 
diff --git a/src/FSharp.Core/prim-types.fs b/src/FSharp.Core/prim-types.fs
index a6d5bcc6ac0..346c1a64e0e 100644
--- a/src/FSharp.Core/prim-types.fs
+++ b/src/FSharp.Core/prim-types.fs
@@ -1549,8 +1549,8 @@ namespace Microsoft.FSharp.Core
             // Run in either PER or ER mode.  In PER mode, equality involving a NaN returns "false".
             // In ER mode, equality on two NaNs returns "true".
             //
-            // If "er" is true the "iec" is fsEqualityComparerNoHashingER
-            // If "er" is false the "iec" is fsEqualityComparerNoHashingPER
+            // If "er" is true the "iec" is fsEqualityComparerUnlimitedHashingER
+            // If "er" is false the "iec" is fsEqualityComparerUnlimitedHashingPER
             let rec GenericEqualityObj (er:bool) (iec:IEqualityComparer) ((xobj:obj),(yobj:obj)) : bool = 
                 (*if objEq xobj yobj then true else  *)
                 match xobj,yobj with 
@@ -1654,28 +1654,186 @@ namespace Microsoft.FSharp.Core
                         else i <- i + 1
                     res
 
+            let isStructuralEquatable (ty: Type) = typeof<IStructuralEquatable>.IsAssignableFrom ty
+            let isArray (ty: Type) = ty.IsArray || (typeof<Array>.IsAssignableFrom ty)
+            let isFloat (ty: Type) = Type.op_Equality(ty, typeof<float>) || Type.op_Equality(ty, typeof<float32>)
+
+            let isValueTuple (ty: Type) =
+                if ty.IsGenericType 
+                then
+                    let typeDef = ty.GetGenericTypeDefinition().FullName
+                    typeDef.Equals "System.ValueTuple`1" ||
+                    typeDef.Equals "System.ValueTuple`2" ||
+                    typeDef.Equals "System.ValueTuple`3" ||
+                    typeDef.Equals "System.ValueTuple`4" ||
+                    typeDef.Equals "System.ValueTuple`5" ||
+                    typeDef.Equals "System.ValueTuple`6" ||
+                    typeDef.Equals "System.ValueTuple`7" ||
+                    typeDef.Equals "System.ValueTuple`8"
+                else false
+
+            let isOptionOrResult (ty: Type) =
+                if ty.IsGenericType 
+                then
+                    let typeDef = ty.GetGenericTypeDefinition().FullName
+                    typeDef.Equals "Microsoft.FSharp.Core.FSharpOption`1" ||
+                    typeDef.Equals "Microsoft.FSharp.Core.FSharpValueOption`1" ||
+                    typeDef.Equals "Microsoft.FSharp.Core.FSharpResult`2"
+                else false
+
+            let isNullable (ty: Type) = 
+                ty.IsGenericType && 
+                ty.GetGenericTypeDefinition().FullName.Equals "System.Nullable`1"
+
+            // A bit hard to grasp right away but think of this as if it was:
+            // 
+            // let canUseDefaultEqualityComparer rootType =
+            //     let processed = HashSet()
+            //   
+            //     let rec checkTypes types =
+            //         match types with
+            //         | [] -> true
+            //         | ty :: rest ->
+            //             if (processed.Add ty) then
+            //                 ... do all the checks
+            //                 checkTypes rest
+            //             else
+            //                 checkTypes rest
+            // 
+            //     checkTypes [ rootType ]
+            //
+            // ... it's just that here in prim types, not much stuff is available yet
+            // so we have to resort to very basic techniques
+            let canUseDefaultEqualityComparer er rootType =
+                let processed = HashSet()
 
-            /// One of the two unique instances of System.Collections.IEqualityComparer. Implements PER semantics
-            /// where equality on NaN returns "false".
-            let fsEqualityComparerNoHashingPER = 
-                { new IEqualityComparer with
-                    override iec.Equals(x:obj,y:obj) = GenericEqualityObj false iec (x,y)  // PER Semantics
-                    override iec.GetHashCode(x:obj) = raise (InvalidOperationException (SR.GetString(SR.notUsedForHashing))) }
-                    
-            /// One of the two unique instances of IEqualityComparer. Implements ER semantics
-            /// where equality on NaN returns "true".
-            let fsEqualityComparerNoHashingER = 
-                { new IEqualityComparer with
-                    override iec.Equals(x:obj,y:obj) = GenericEqualityObj true iec (x,y)  // ER Semantics
-                    override iec.GetHashCode(x:obj) = raise (InvalidOperationException (SR.GetString(SR.notUsedForHashing))) }
+                let rec checkType index (types: Type array) =
+                    if types.Length = index then true
+                    else
+                        let ty = get types index
+
+                        if processed.Add ty 
+                        then
+                            // avoid any types that need special handling in GenericEqualityObj
+                            // GenericEqualityObj handles string as a special case, but internally routes to same equality
+
+                            // covers enum and value types
+                            // reference types need to be sealed as derived class might implement IStructuralEquatable
+                            ty.IsSealed
+
+                            // handled elsewhere in a specialized fashion
+                            && not (isArray ty)
+                            && (er || not (isFloat ty))
+
+                            // analyze generic types
+                            && (match ty with
+                                | ty when isNullable ty ||
+                                          isStructuralEquatable ty && isValueTuple ty ||
+                                          isStructuralEquatable ty && isOptionOrResult ty -> checkType 0 (ty.GetGenericArguments())
+                                
+                                | ty when isStructuralEquatable ty -> false
+                                
+                                | _ -> true)
+
+                            && checkType (index + 1) types
+                        
+                        else
+                            checkType (index + 1) types
+
+                checkType 0 [| rootType |]
+
+            let arrayEqualityComparer<'T> er comparer =
+                let arrayEquals (er: bool) (iec: IEqualityComparer) (xobj: obj) (yobj: obj) : bool = 
+                    match xobj, yobj with 
+                    | null, null -> true
+                    | null, _ -> false
+                    | _, null -> false
+                    | (:? (obj array)      as arr1), (:? (obj array)      as arr2) -> GenericEqualityObjArray    er iec arr1 arr2
+                    | (:? (byte array)     as arr1), (:? (byte array)     as arr2) -> GenericEqualityByteArray          arr1 arr2
+                    | (:? (int32 array)    as arr1), (:? (int32 array)    as arr2) -> GenericEqualityInt32Array         arr1 arr2
+                    | (:? (int64 array)    as arr1), (:? (int64 array)    as arr2) -> GenericEqualityInt64Array         arr1 arr2
+                    | (:? (char array)     as arr1), (:? (char array)     as arr2) -> GenericEqualityCharArray          arr1 arr2
+                    | (:? (float32 array)  as arr1), (:? (float32 array)  as arr2) -> GenericEqualitySingleArray er     arr1 arr2
+                    | (:? (float array)    as arr1), (:? (float array)    as arr2) -> GenericEqualityDoubleArray er     arr1 arr2
+                    | (:? Array            as arr1), (:? Array            as arr2) -> GenericEqualityArbArray    er iec arr1 arr2
+                    | _ -> raise (Exception "invalid logic - expected array")
+
+                let getHashCode (iec, xobj: obj) =
+                    match xobj with 
+                    | null -> 0 
+                    | :? (obj array)      as oa -> GenericHashObjArray iec oa 
+                    | :? (byte array)     as ba -> GenericHashByteArray ba 
+                    | :? (int array)      as ia -> GenericHashInt32Array ia 
+                    | :? (int64 array)    as ia -> GenericHashInt64Array ia 
+                    | :? Array            as a  -> GenericHashArbArray iec a 
+                    | _ -> raise (Exception "invalid logic - expected array")
+
+                { new EqualityComparer<'T>() with
+                    member _.Equals (x, y) = arrayEquals er comparer (box x) (box y)
+                    member _.GetHashCode x = getHashCode (fsEqualityComparerUnlimitedHashingPER, box x) }
+
+            let structuralEqualityComparer<'T> comparer =
+                { new EqualityComparer<'T>() with
+                    member _.Equals (x,y) =
+                        match box x, box y with 
+                        | null, null -> true
+                        | null, _    -> false
+                        | _,    null -> false
+                        | (:? IStructuralEquatable as x1), yobj -> x1.Equals (yobj, comparer)
+                        | _ -> raise (Exception "invalid logic - expected IStructuralEquatable")
+
+                    member _.GetHashCode x =
+                        match box x with 
+                        | null -> 0 
+                        | :? IStructuralEquatable as a -> a.GetHashCode fsEqualityComparerUnlimitedHashingPER
+                        | _ -> raise (Exception "invalid logic - expected IStructuralEquatable") }
+
+            let getEqualityComparer<'T> er =
+                let ty = typeof<'T>
+
+                match er with
+                | _ when canUseDefaultEqualityComparer er ty -> EqualityComparer<'T>.Default
+
+                | true when isArray ty -> arrayEqualityComparer true fsEqualityComparerUnlimitedHashingER
+                | false when isArray ty -> arrayEqualityComparer false fsEqualityComparerUnlimitedHashingPER
+                | true when isStructuralEquatable ty -> structuralEqualityComparer fsEqualityComparerUnlimitedHashingER
+                | false when isStructuralEquatable ty -> structuralEqualityComparer fsEqualityComparerUnlimitedHashingPER
+
+                | false when Type.op_Equality(ty, typeof<float>) -> unboxPrim (box {
+                    new EqualityComparer<float>() with
+                        member _.Equals (x,y) = (# "ceq" x y : bool #)
+                        member _.GetHashCode x = x.GetHashCode () })
+
+                | false when Type.op_Equality(ty, typeof<float32>) -> unboxPrim (box {
+                    new EqualityComparer<float32>() with
+                        member _.Equals (x,y) = (# "ceq" x y : bool #)
+                        member _.GetHashCode x = x.GetHashCode () })
+
+                | false -> { 
+                    new EqualityComparer<'T>() with
+                        member _.Equals (x,y) = GenericEqualityObj false fsEqualityComparerUnlimitedHashingPER (box x, box y)
+                        member _.GetHashCode x = GenericHashParamObj fsEqualityComparerUnlimitedHashingPER (box x) }
+
+                | true -> { 
+                    new EqualityComparer<'T>() with
+                        member _.Equals (x,y) = GenericEqualityObj true fsEqualityComparerUnlimitedHashingER (box x, box y)
+                        member _.GetHashCode x = GenericHashParamObj fsEqualityComparerUnlimitedHashingER (box x) }
+
+            type EqualityComparerER<'T> () =
+
+                static member val Comparer = getEqualityComparer<'T> true
+
+            type EqualityComparerPER<'T> () =
+
+                static member val Comparer = getEqualityComparer<'T> false
 
             /// Implements generic equality between two values, with PER semantics for NaN (so equality on two NaN values returns false)
             //
             // The compiler optimizer is aware of this function  (see use of generic_equality_per_inner_vref in opt.fs)
             // and devirtualizes calls to it based on "T".
             let GenericEqualityIntrinsic (x : 'T) (y : 'T) : bool = 
-                GenericEqualityObj false fsEqualityComparerNoHashingPER ((box x), (box y))
-                
+                EqualityComparerPER<'T>.Comparer.Equals (x, y)
+
             /// Implements generic equality between two values, with ER semantics for NaN (so equality on two NaN values returns true)
             //
             // ER semantics is used for recursive calls when implementing .Equals(that) for structural data, see the code generated for record and union types in augment.fs
@@ -1683,15 +1841,20 @@ namespace Microsoft.FSharp.Core
             // The compiler optimizer is aware of this function (see use of generic_equality_er_inner_vref in opt.fs)
             // and devirtualizes calls to it based on "T".
             let GenericEqualityERIntrinsic (x : 'T) (y : 'T) : bool =
-                GenericEqualityObj true fsEqualityComparerNoHashingER ((box x), (box y))
+                EqualityComparerER<'T>.Comparer.Equals (x, y)
 
             /// Implements generic equality between two values using "comp" for recursive calls.
             //
             // The compiler optimizer is aware of this function  (see use of generic_equality_withc_inner_vref in opt.fs)
             // and devirtualizes calls to it based on "T", and under the assumption that "comp" 
-            // is either fsEqualityComparerNoHashingER or fsEqualityComparerNoHashingPER.
+            // is either fsEqualityComparerUnlimitedHashingER or fsEqualityComparerUnlimitedHashingPER.
             let GenericEqualityWithComparerIntrinsic (comp : IEqualityComparer) (x : 'T) (y : 'T) : bool =
-                comp.Equals((box x),(box y))
+                if obj.ReferenceEquals (comp, fsEqualityComparerUnlimitedHashingPER) then
+                    EqualityComparerPER<'T>.Comparer.Equals (x, y)
+                elif obj.ReferenceEquals (comp, fsEqualityComparerUnlimitedHashingER) then
+                    EqualityComparerER<'T>.Comparer.Equals (x, y)
+                else
+                    comp.Equals ((box x), (box y))
                 
 
             /// Implements generic equality between two values, with ER semantics for NaN (so equality on two NaN values returns true)
@@ -1810,7 +1973,7 @@ namespace Microsoft.FSharp.Core
             //
             // NOTE: The compiler optimizer is aware of this function (see uses of generic_hash_inner_vref in opt.fs)
             // and devirtualizes calls to it based on type "T".
-            let GenericHashIntrinsic input = GenericHashParamObj fsEqualityComparerUnlimitedHashingPER (box input)
+            let GenericHashIntrinsic input = EqualityComparerPER<'T>.Comparer.GetHashCode input
 
             /// Intrinsic for calls to depth-limited structural hashing that were not optimized by static conditionals.
             let LimitedGenericHashIntrinsic limit input = GenericHashParamObj (CountLimitedHasherPER(limit)) (box input)
@@ -1823,7 +1986,10 @@ namespace Microsoft.FSharp.Core
             // NOTE: The compiler optimizer is aware of this function (see uses of generic_hash_withc_inner_vref in opt.fs)
             // and devirtualizes calls to it based on type "T".
             let GenericHashWithComparerIntrinsic<'T> (comp : IEqualityComparer) (input : 'T) : int =
-                GenericHashParamObj comp (box input)
+                if obj.ReferenceEquals (comp, fsEqualityComparerUnlimitedHashingPER) then
+                    EqualityComparerPER<'T>.Comparer.GetHashCode input
+                else
+                    GenericHashParamObj comp (box input)
                 
             let inline HashString (s:string) = 
                  match s with 
@@ -2136,46 +2302,8 @@ namespace Microsoft.FSharp.Core
                   member _.GetHashCode(x) = GenericLimitedHash limit x 
                   member _.Equals(x,y) = GenericEquality x y }
 
-        let BoolIEquality    = MakeGenericEqualityComparer<bool>()
-        let CharIEquality    = MakeGenericEqualityComparer<char>()
-        let StringIEquality  = MakeGenericEqualityComparer<string>()
-        let SByteIEquality   = MakeGenericEqualityComparer<sbyte>()
-        let Int16IEquality   = MakeGenericEqualityComparer<int16>()
-        let Int32IEquality   = MakeGenericEqualityComparer<int32>()
-        let Int64IEquality   = MakeGenericEqualityComparer<int64>()
-        let IntPtrIEquality  = MakeGenericEqualityComparer<nativeint>()
-        let ByteIEquality    = MakeGenericEqualityComparer<byte>()
-        let UInt16IEquality  = MakeGenericEqualityComparer<uint16>()
-        let UInt32IEquality  = MakeGenericEqualityComparer<uint32>()
-        let UInt64IEquality  = MakeGenericEqualityComparer<uint64>()
-        let UIntPtrIEquality = MakeGenericEqualityComparer<unativeint>()
-        let FloatIEquality   = MakeGenericEqualityComparer<float>()
-        let Float32IEquality = MakeGenericEqualityComparer<float32>()
-        let DecimalIEquality = MakeGenericEqualityComparer<decimal>()
-
-        type FastGenericEqualityComparerTable<'T>() = 
-            static let f : IEqualityComparer<'T> = 
-                match typeof<'T> with 
-                | ty when Type.op_Equality(ty, typeof<bool>)       -> unboxPrim (box BoolIEquality)
-                | ty when Type.op_Equality(ty, typeof<byte>)       -> unboxPrim (box ByteIEquality)
-                | ty when Type.op_Equality(ty, typeof<int32>)      -> unboxPrim (box Int32IEquality)
-                | ty when Type.op_Equality(ty, typeof<uint32>)     -> unboxPrim (box UInt32IEquality)
-                | ty when Type.op_Equality(ty, typeof<char>)       -> unboxPrim (box CharIEquality)
-                | ty when Type.op_Equality(ty, typeof<sbyte>)      -> unboxPrim (box SByteIEquality)
-                | ty when Type.op_Equality(ty, typeof<int16>)      -> unboxPrim (box Int16IEquality)
-                | ty when Type.op_Equality(ty, typeof<int64>)      -> unboxPrim (box Int64IEquality)
-                | ty when Type.op_Equality(ty, typeof<nativeint>)  -> unboxPrim (box IntPtrIEquality)
-                | ty when Type.op_Equality(ty, typeof<uint16>)     -> unboxPrim (box UInt16IEquality)
-                | ty when Type.op_Equality(ty, typeof<uint64>)     -> unboxPrim (box UInt64IEquality)
-                | ty when Type.op_Equality(ty, typeof<unativeint>) -> unboxPrim (box UIntPtrIEquality)
-                | ty when Type.op_Equality(ty, typeof<float>)      -> unboxPrim (box FloatIEquality)
-                | ty when Type.op_Equality(ty, typeof<float32>)    -> unboxPrim (box Float32IEquality)
-                | ty when Type.op_Equality(ty, typeof<decimal>)    -> unboxPrim (box DecimalIEquality)
-                | ty when Type.op_Equality(ty, typeof<string>)     -> unboxPrim (box StringIEquality)
-                | _ -> MakeGenericEqualityComparer<'T>()
-            static member Function : IEqualityComparer<'T> = f
-
-        let FastGenericEqualityComparerFromTable<'T> = FastGenericEqualityComparerTable<'T>.Function
+        let FastGenericEqualityComparerFromTable<'T> = 
+            HashCompare.EqualityComparerPER<'T>.Comparer : IEqualityComparer<'T>
 
         // This is the implementation of HashIdentity.Structural.  In most cases this just becomes
         // FastGenericEqualityComparerFromTable.
diff --git a/src/FSharp.Core/printf.fs b/src/FSharp.Core/printf.fs
index 7afcce1e66b..a326492c672 100644
--- a/src/FSharp.Core/printf.fs
+++ b/src/FSharp.Core/printf.fs
@@ -546,7 +546,7 @@ module internal PrintfImpl =
     /// A wrapper struct used to slightly strengthen the types of "ValueConverter" objects produced during composition of
     /// the dynamic implementation.  These are always functions but sometimes they take one argument, sometimes two.
     [<Struct; NoEquality; NoComparison>]
-    type ValueConverter private (f: obj) =
+    type ValueConverter internal (f: obj) =
         member x.FuncObj = f
 
         static member inline Make (f: obj -> string) = ValueConverter(box f)
@@ -981,9 +981,9 @@ module internal PrintfImpl =
         let defaultFormat = getFormatForFloat spec.TypeChar DefaultPrecision
         FloatAndDecimal.withPadding spec (getFormatForFloat spec.TypeChar) defaultFormat
 
-    let private NonPublicStatics = BindingFlags.NonPublic ||| BindingFlags.Static
+    let private AllStatics = BindingFlags.Public ||| BindingFlags.NonPublic ||| BindingFlags.Static
 
-    let mi_GenericToString = typeof<ObjectPrinter>.GetMethod("GenericToString", NonPublicStatics)
+    let mi_GenericToString = typeof<ObjectPrinter>.GetMethod("GenericToString", AllStatics)
 
     let private getValueConverter (ty: Type) (spec: FormatSpecifier) : ValueConverter = 
         match spec.TypeChar with
@@ -1103,7 +1103,7 @@ module internal PrintfImpl =
                 // %a has an existential type which must be converted to obj
                 assert (argTys.Length = 2)
                 let captureMethName = "CaptureLittleA" 
-                let mi = typeof<Specializations<'State, 'Residue, 'Result>>.GetMethod(captureMethName, NonPublicStatics)
+                let mi = typeof<Specializations<'State, 'Residue, 'Result>>.GetMethod(captureMethName, AllStatics)
                 let mi = mi.MakeGenericMethod([| argTys.[1]; retTy |])
                 let factoryObj = mi.Invoke(null, [| next  |])
                 factoryObj, false, argTys, retTy, None
@@ -1115,20 +1115,20 @@ module internal PrintfImpl =
                 match nextNextOpt with 
                 | None ->
                     let captureMethName = "CaptureFinal" + string captureCount
-                    let mi = typeof<Specializations<'State, 'Residue, 'Result>>.GetMethod(captureMethName, NonPublicStatics)
+                    let mi = typeof<Specializations<'State, 'Residue, 'Result>>.GetMethod(captureMethName, AllStatics)
                     let mi = mi.MakeGenericMethod(combinedArgTys)
                     let factoryObj = mi.Invoke(null, [| allSteps |])
                     factoryObj, true, combinedArgTys, nextRetTy, None
                 | Some nextNext ->
                     let captureMethName = "Capture" + string captureCount
-                    let mi = typeof<Specializations<'State, 'Residue, 'Result>>.GetMethod(captureMethName, NonPublicStatics)
+                    let mi = typeof<Specializations<'State, 'Residue, 'Result>>.GetMethod(captureMethName, AllStatics)
                     let mi = mi.MakeGenericMethod(Array.append combinedArgTys [| nextRetTy |])
                     let factoryObj = mi.Invoke(null, [| nextNext |])
                     factoryObj, true, combinedArgTys, nextRetTy, nextNextOpt
 
             | captureCount, _ ->
                 let captureMethName = "Capture" + string captureCount
-                let mi = typeof<Specializations<'State, 'Residue, 'Result>>.GetMethod(captureMethName, NonPublicStatics)
+                let mi = typeof<Specializations<'State, 'Residue, 'Result>>.GetMethod(captureMethName, AllStatics)
                 let mi = mi.MakeGenericMethod(Array.append argTys [| retTy |])
                 let factoryObj = mi.Invoke(null, [| next  |])
                 factoryObj, true, argTys, retTy, Some next
@@ -1277,7 +1277,7 @@ module internal PrintfImpl =
             // If there is one simple format specifier then we can create an even better factory function
             | [| StepWithArg (prefix1, conv1); StepString prefix2 |] ->
                 let captureMethName = "OneStepWithArg" 
-                let mi = typeof<Specializations<'State, 'Residue, 'Result>>.GetMethod(captureMethName, NonPublicStatics)
+                let mi = typeof<Specializations<'State, 'Residue, 'Result>>.GetMethod(captureMethName, AllStatics)
                 let mi = mi.MakeGenericMethod(combinedArgTys)
                 let factoryObj = mi.Invoke(null, [| box prefix1; box conv1; box prefix2  |])
                 factoryObj
@@ -1285,7 +1285,7 @@ module internal PrintfImpl =
             // If there are two simple format specifiers then we can create an even better factory function
             | [| StepWithArg (prefix1, conv1); StepWithArg (prefix2, conv2); StepString prefix3 |] ->
                 let captureMethName = "TwoStepWithArg" 
-                let mi = typeof<Specializations<'State, 'Residue, 'Result>>.GetMethod(captureMethName, NonPublicStatics)
+                let mi = typeof<Specializations<'State, 'Residue, 'Result>>.GetMethod(captureMethName, AllStatics)
                 let mi = mi.MakeGenericMethod(combinedArgTys)
                 let factoryObj = mi.Invoke(null, [| box prefix1; box conv1; box prefix2; box conv2; box prefix3 |])
                 factoryObj
diff --git a/tests/AheadOfTime/Equality/Equality.fsproj b/tests/AheadOfTime/Equality/Equality.fsproj
new file mode 100644
index 00000000000..f5a243c65b9
--- /dev/null
+++ b/tests/AheadOfTime/Equality/Equality.fsproj
@@ -0,0 +1,35 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <LangVersion>preview</LangVersion>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
+    <DisableImplicitNuGetFallbackFolder>true</DisableImplicitNuGetFallbackFolder>
+    <DisableImplicitLibraryPacksFolder>true</DisableImplicitLibraryPacksFolder>
+    <PublishTrimmed>true</PublishTrimmed>
+    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <DotnetFscCompilerPath>$(MSBuildThisFileDirectory)../../../artifacts/bin/fsc/Release/net8.0/fsc.dll</DotnetFscCompilerPath>
+    <Fsc_DotNET_DotnetFscCompilerPath>$(MSBuildThisFileDirectory)../../../artifacts/bin/fsc/Release/net8.0/fsc.dll</Fsc_DotNET_DotnetFscCompilerPath>
+    <FSharpPreferNetFrameworkTools>False</FSharpPreferNetFrameworkTools>
+    <FSharpPrefer64BitTools>True</FSharpPrefer64BitTools>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <Import Project="$(MSBuildThisFileDirectory)../../../eng/Versions.props" />
+
+  <ItemGroup>
+    <PackageReference Include="FSharp.Core" Version="$(FSharpCorePreviewPackageVersionValue)"/>
+  </ItemGroup>
+
+</Project>
\ No newline at end of file
diff --git a/tests/AheadOfTime/Equality/Program.fs b/tests/AheadOfTime/Equality/Program.fs
new file mode 100644
index 00000000000..052d2875da3
--- /dev/null
+++ b/tests/AheadOfTime/Equality/Program.fs
@@ -0,0 +1,77 @@
+open System.Collections.Generic
+open NonStructuralComparison
+
+let failures = HashSet<string>()
+
+let reportFailure (s: string) = 
+    stderr.Write " NO: "
+    stderr.WriteLine s
+    failures.Add s |> ignore
+
+let test testName x y =
+    let result = HashIdentity.Structural.Equals(x, y)
+    if result = false
+    then
+        stderr.WriteLine($"\n***** {testName}: Expected: 'true' Result: '{result}' = FAIL\n");
+        reportFailure testName
+
+module BasicTypes =
+    test "test000" true true
+    test "test001" 1y 1y
+    test "test002" 1uy 1uy
+    test "test003" 1s 1s
+    test "test004" 1us 1us
+    test "test005" 1 1
+    test "test006" 1u 1u
+    test "test007" 1L 1L
+    test "test008" 1UL 1UL
+    test "test009" (nativeint 1) (nativeint 1)
+    test "test010" (unativeint 1) (unativeint 1)
+    test "test011" 'a' 'a'
+    test "test012" "a" "a"
+    test "test013" 1m 1m
+    test "test014" 1.0 1.0
+    test "test015" 1.0f 1.0f
+
+module Arrays =
+    test "test100" [|1|] [|1|]
+    test "test101" [|1L|] [|1L|]
+    test "test102" [|1uy|] [|1uy|]
+    test "test103" [|box 1|] [|box 1|]
+
+module Structs = 
+    test "test200" struct (1, 1) struct (1, 1)
+    test "test201" struct (1, 1, 1) struct (1, 1, 1)
+    test "test202" struct (1, 1, 1, 1) struct (1, 1, 1, 1)
+    test "test203" struct (1, 1, 1, 1, 1) struct (1, 1, 1, 1, 1)
+    test "test204" struct (1, 1, 1, 1, 1, 1) struct (1, 1, 1, 1, 1, 1)
+    test "test205" struct (1, 1, 1, 1, 1, 1, 1) struct (1, 1, 1, 1, 1, 1, 1)
+    test "test206" struct (1, 1, 1, 1, 1, 1, 1, 1) struct (1, 1, 1, 1, 1, 1, 1, 1)
+
+module OptionsAndCo = 
+    open System
+
+    test "test301" (Some 1) (Some 1)
+    test "test302" (ValueSome 1) (ValueSome 1)
+    test "test303" (Ok 1) (Ok 1)
+    test "test304" (Nullable 1) (Nullable 1)
+
+module Enums =
+    open System
+
+    type SomeEnum = 
+        | Case0 = 0
+        | Case1 = 1
+
+    test "test401" (enum<SomeEnum>(1)) (enum<SomeEnum>(1)) 
+    test "test402" (enum<DayOfWeek>(1)) (enum<DayOfWeek>(1)) 
+
+[<EntryPoint>]
+let main _ =
+    match failures with 
+    | set when set.Count = 0 -> 
+        stdout.WriteLine "All tests passed"
+        exit 0
+    | _ -> 
+        stdout.WriteLine "Some tests failed"
+        exit 1
diff --git a/tests/AheadOfTime/Equality/check.ps1 b/tests/AheadOfTime/Equality/check.ps1
new file mode 100644
index 00000000000..7913d24599c
--- /dev/null
+++ b/tests/AheadOfTime/Equality/check.ps1
@@ -0,0 +1,32 @@
+Write-Host "Publish and Execute: net8.0 - Equality"
+
+$build_output = dotnet publish -restore -c release -f:net8.0 $(Join-Path $PSScriptRoot Equality.fsproj)
+
+# Checking that the build succeeded
+if ($LASTEXITCODE -ne 0)
+{
+    Write-Error "Build failed with exit code ${LASTEXITCODE}"
+    Write-Error "${build_output}" -ErrorAction Stop
+}
+
+$process = Start-Process `
+    -FilePath $(Join-Path $PSScriptRoot bin\release\net8.0\win-x64\publish\Equality.exe) `
+    -Wait `
+    -NoNewWindow `
+    -PassThru `
+    -RedirectStandardOutput $(Join-Path $PSScriptRoot output.txt)
+
+$output = Get-Content $(Join-Path $PSScriptRoot output.txt)
+
+# Checking that it is actually running.
+if ($LASTEXITCODE -ne 0)
+{
+    Write-Error "Test failed with exit code ${LASTEXITCODE}" -ErrorAction Stop
+}
+
+# Checking that the output is as expected.
+$expected = "All tests passed"
+if ($output -ne $expected)
+{
+    Write-Error "Test failed with unexpected output:`nExpected:`n`t${expected}`nActual`n`t${output}" -ErrorAction Stop
+}
diff --git a/tests/AheadOfTime/Trimming/check.cmd b/tests/AheadOfTime/Trimming/check.cmd
deleted file mode 100644
index 4eefff011c5..00000000000
--- a/tests/AheadOfTime/Trimming/check.cmd
+++ /dev/null
@@ -1,2 +0,0 @@
-@echo off
-powershell -ExecutionPolicy ByPass -NoProfile -command "& """%~dp0check.ps1""""
diff --git a/tests/AheadOfTime/Trimming/check.ps1 b/tests/AheadOfTime/Trimming/check.ps1
index 8528710b76f..7412b21232c 100644
--- a/tests/AheadOfTime/Trimming/check.ps1
+++ b/tests/AheadOfTime/Trimming/check.ps1
@@ -39,7 +39,7 @@ function CheckTrim($root, $tfm, $outputfile, $expected_len) {
 # error NETSDK1124: Trimming assemblies requires .NET Core 3.0 or higher.
 
 # Check net7.0 trimmed assemblies
-CheckTrim -root "SelfContained_Trimming_Test" -tfm "net8.0" -outputfile "FSharp.Core.dll" -expected_len 287232
+CheckTrim -root "SelfContained_Trimming_Test" -tfm "net8.0" -outputfile "FSharp.Core.dll" -expected_len 284160
 
-# Check net7.0 trimmed assemblies
-CheckTrim -root "StaticLinkedFSharpCore_Trimming_Test" -tfm "net8.0" -outputfile "StaticLinkedFSharpCore_Trimming_Test.dll" -expected_len 8820736
+# Check net8.0 trimmed assemblies
+CheckTrim -root "StaticLinkedFSharpCore_Trimming_Test" -tfm "net8.0" -outputfile "StaticLinkedFSharpCore_Trimming_Test.dll" -expected_len 8817152
diff --git a/tests/AheadOfTime/check.cmd b/tests/AheadOfTime/check.cmd
new file mode 100644
index 00000000000..a52368e2c6f
--- /dev/null
+++ b/tests/AheadOfTime/check.cmd
@@ -0,0 +1,3 @@
+@echo off
+powershell -ExecutionPolicy ByPass -NoProfile -command "& """%~dp0Trimming\check.ps1""""
+powershell -ExecutionPolicy ByPass -NoProfile -command "& """%~dp0Equality\check.ps1""""
diff --git a/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsc/misc/compiler_help_output.bsl b/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsc/misc/compiler_help_output.bsl
index 2e064aacf82..8e207799112 100644
--- a/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsc/misc/compiler_help_output.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsc/misc/compiler_help_output.bsl
@@ -59,6 +59,7 @@ Copyright (c) Microsoft Corporation. All Rights Reserved.
 --tailcalls[+|-]                         Enable or disable tailcalls
 --deterministic[+|-]                     Produce a deterministic assembly (including module version GUID and
                                          timestamp)
+--realsig[+|-]                           Generate assembly with IL visibility that matches the source code visibility
 --pathmap:<path=sourcePath;...>          Maps physical paths to source path names output by the compiler
 --crossoptimize[+|-]                     Enable or disable cross-module optimizations
 --reflectionfree                         Disable implicit generation of constructs using reflection
diff --git a/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/CustomAttributes/AttributeUsage/AttributeTargetsIsMethod01.fs b/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/CustomAttributes/AttributeUsage/AttributeTargetsIsMethod01.fs
index b8de3b3349a..4018ae74be8 100644
--- a/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/CustomAttributes/AttributeUsage/AttributeTargetsIsMethod01.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/CustomAttributes/AttributeUsage/AttributeTargetsIsMethod01.fs
@@ -48,3 +48,10 @@ let test1 =
     |> (=) 6
     
 if not test1 then failwith "Failed: 1"
+
+[<AttributeUsage(AttributeTargets.Method)>]
+type MethodLevelAttribute() =
+    inherit Attribute()
+
+type SomeUnion =
+| [<MethodLevel>] Case1 of int
diff --git a/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/CustomAttributes/AttributeUsage/AttributeUsage.fs b/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/CustomAttributes/AttributeUsage/AttributeUsage.fs
index c7861ee3e56..5d930ea1e14 100644
--- a/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/CustomAttributes/AttributeUsage/AttributeUsage.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/CustomAttributes/AttributeUsage/AttributeUsage.fs
@@ -34,7 +34,7 @@ module CustomAttributes_AttributeUsage =
         |> verifyCompileAndRun
         |> shouldSucceed
 
-    // SOURCE=AssemblyVersion03.fs							# AssemblyVersion03.fs
+    // SOURCE=AssemblyVersion03.fs                          # AssemblyVersion03.fs
     [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"AssemblyVersion03.fs"|])>]
     let ``AssemblyVersion03_fs`` compilation =
         compilation
@@ -64,6 +64,14 @@ module CustomAttributes_AttributeUsage =
         |> verifyCompileAndRun
         |> shouldSucceed
 
+    // SOURCE=AttributeTargetsIsMethod01.fs				# AttributeTargetsIsMethod01.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"AttributeTargetsIsMethod01.fs"|])>]
+    let ``AttributeTargetsIsMethod01_fs preview`` compilation =
+        compilation
+        |> withLangVersionPreview
+        |> verifyCompileAndRun
+        |> shouldSucceed
+
     // SOURCE=ConditionalAttribute.fs					# ConditionalAttribute.fs
     [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ConditionalAttribute.fs"|])>]
     let ``ConditionalAttribute_fs`` compilation =
@@ -352,5 +360,45 @@ module CustomAttributes_AttributeUsage =
         |> withDiagnostics [
             (Warning 2003, Line 5, Col 59, Line 5, Col 68, "The attribute System.Reflection.AssemblyFileVersionAttribute specified version '9.8.*.6', but this value is invalid and has been ignored")
         ]
-
-
+        
+    // SOURCE=E_AttributeTargetIsField03.fs	# E_AttributeTargetIsField03.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"E_AttributeTargetIsField03.fs"|])>]
+    let ``E_AttributeTargetIsField03_fs`` compilation =
+        compilation
+        |> verifyCompile
+        |> shouldFail
+        |> withDiagnostics [
+            (Error 842, Line 14, Col 5, Line 14, Col 15, "This attribute is not valid for use on this language element")
+        ]
+    
+    // SOURCE=E_AttributeTargetIsField03.fs	# E_AttributeTargetIsField03.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"E_AttributeTargetIsField03.fs"|])>]
+    let ``E_AttributeTargetIsField03_fs preview`` compilation =
+        compilation
+        |> withLangVersionPreview
+        |> verifyCompile
+        |> shouldFail
+        |> withDiagnostics [
+            (Error 842, Line 14, Col 5, Line 14, Col 15, "This attribute is not valid for use on this language element")
+            (Error 842, Line 15, Col 5, Line 15, Col 25, "This attribute is not valid for use on this language element")
+        ]
+        
+        
+    // SOURCE=E_AttributeTargetIsProperty01.fs	# E_AttributeTargetIsField03.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"E_AttributeTargetIsProperty01.fs"|])>]
+    let ``E_AttributeTargetIsProperty01_fs`` compilation =
+        compilation
+        |> verifyCompile
+        |> shouldSucceed
+    
+    // SOURCE=E_AttributeTargetIsProperty01.fs	# E_AttributeTargetIsField03.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"E_AttributeTargetIsProperty01.fs"|])>]
+    let ``E_AttributeTargetIsProperty01_fs preview`` compilation =
+        compilation
+        |> withLangVersionPreview
+        |> verifyCompile
+        |> shouldFail
+        |> withDiagnostics [
+            (Error 842, Line 14, Col 5, Line 14, Col 18, "This attribute is not valid for use on this language element")
+            (Error 842, Line 15, Col 5, Line 15, Col 25, "This attribute is not valid for use on this language element")
+        ]
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/CustomAttributes/AttributeUsage/E_AttributeTargetIsField03.fs b/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/CustomAttributes/AttributeUsage/E_AttributeTargetIsField03.fs
new file mode 100644
index 00000000000..cc5fb20b495
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/CustomAttributes/AttributeUsage/E_AttributeTargetIsField03.fs
@@ -0,0 +1,16 @@
+// This tests that AttributeTargets.Field  is not allowed in union-case declaration
+
+open System
+
+[<AttributeUsage(AttributeTargets.Field)>]
+type FieldLevelAttribute() =
+    inherit Attribute()
+
+[<AttributeUsage(AttributeTargets.Property ||| AttributeTargets.Field)>]
+type PropertyOrFieldLevelAttribute() =
+    inherit Attribute()
+
+type SomeUnion =
+| [<FieldLevel>] Case1 of int  // Should fail
+| [<PropertyOrFieldLevel>] Case2 of int  // Should fail
+
diff --git a/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/CustomAttributes/AttributeUsage/E_AttributeTargetIsProperty01.fs b/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/CustomAttributes/AttributeUsage/E_AttributeTargetIsProperty01.fs
new file mode 100644
index 00000000000..4627c3680dd
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/CustomAttributes/AttributeUsage/E_AttributeTargetIsProperty01.fs
@@ -0,0 +1,15 @@
+// This tests that AttributeTargets.Property  is not allowed in union-case declaration
+
+open System
+
+[<AttributeUsage(AttributeTargets.Property)>]
+type PropertyLevelAttribute() =
+    inherit Attribute()
+
+[<AttributeUsage(AttributeTargets.Property ||| AttributeTargets.Field)>]
+type PropertyOrFieldLevelAttribute() =
+    inherit Attribute()
+
+type SomeUnion =
+| [<PropertyLevel>] Case1 of int // Should fail
+| [<PropertyOrFieldLevel>] Case2 of int // Should fail
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/MethodResolution.fs b/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/MethodResolution.fs
index 3ac3d49ce4b..f6145c01abc 100644
--- a/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/MethodResolution.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/MethodResolution.fs
@@ -34,7 +34,7 @@ if returnvalue2<> true && value2 <> 7 then
         |> ignore
 
     [<Fact>]
-    let ``Method with optional and out parameters resolves correctly (verify IL)`` () =
+    let ``Method with optional and out parameters resolves correctly withRealInternalSignatureOff (verify IL)`` () =
         FSharp """
 module OutOptionalTests
 open System.Runtime.InteropServices
@@ -47,6 +47,7 @@ let (_:bool), (_:int) = Thing.Do(i = 42)
 let (_:bool), (_:int) = Thing.Do()
         """
         |> ignoreWarnings
+        |> withRealInternalSignatureOff
         |> compile
         |> shouldSucceed
         |> verifyIL [
@@ -203,6 +204,195 @@ extends [runtime]System.Object
 }
         """]
 
+    [<Fact>]
+    let ``Method with optional and out parameters resolves correctly withRealInternalSignatureOn (verify IL)`` () =
+        FSharp """
+module OutOptionalTests
+open System.Runtime.InteropServices
+
+type Thing =
+    static member Do(o: outref<int>, [<Optional; DefaultParameterValue(1)>]i: int) = 
+        o <- i
+        i = 7
+let (_:bool), (_:int) = Thing.Do(i = 42)
+let (_:bool), (_:int) = Thing.Do()
+        """
+        |> ignoreWarnings
+        |> withRealInternalSignatureOn
+        |> compile
+        |> shouldSucceed
+        |> verifyIL [
+        """
+.class public abstract auto ansi sealed OutOptionalTests
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public Thing
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public static bool  Do([out] int32& o,
+                                   [opt] int32 i) cil managed
+    {
+      .param [2] = int32(0x00000001)
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stobj      [runtime]System.Int32
+      IL_0007:  ldarg.1
+      IL_0008:  ldc.i4.7
+      IL_0009:  ceq
+      IL_000b:  ret
+    } 
+
+  } 
+
+  .field static assembly class [runtime]System.Tuple`2<bool,int32> patternInput@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 outArg@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<bool,int32> 'patternInput@10-1'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 'outArg@10-1'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method assembly specialname static class [runtime]System.Tuple`2<bool,int32> get_patternInput@9() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<bool,int32> OutOptionalTests::patternInput@9
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static int32 get_outArg@9() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 OutOptionalTests::outArg@9
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static void set_outArg@9(int32 'value') cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  stsfld     int32 OutOptionalTests::outArg@9
+    IL_0006:  ret
+  } 
+
+  .method assembly specialname static class [runtime]System.Tuple`2<bool,int32> 'get_patternInput@10-1'() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<bool,int32> OutOptionalTests::'patternInput@10-1'
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static int32 'get_outArg@10-1'() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 OutOptionalTests::'outArg@10-1'
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static void 'set_outArg@10-1'(int32 'value') cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  stsfld     int32 OutOptionalTests::'outArg@10-1'
+    IL_0006:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$OutOptionalTests::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$OutOptionalTests::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (int32& V_0)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 OutOptionalTests::outArg@9
+    IL_0006:  ldsflda    int32 OutOptionalTests::outArg@9
+    IL_000b:  stloc.0
+    IL_000c:  ldloc.0
+    IL_000d:  ldc.i4.s   42
+    IL_000f:  stobj      [runtime]System.Int32
+    IL_0014:  ldc.i4.0
+    IL_0015:  call       int32 OutOptionalTests::get_outArg@9()
+    IL_001a:  newobj     instance void class [runtime]System.Tuple`2<bool,int32>::.ctor(!0,
+                                                                                         !1)
+    IL_001f:  stsfld     class [runtime]System.Tuple`2<bool,int32> OutOptionalTests::patternInput@9
+    IL_0024:  ldc.i4.0
+    IL_0025:  stsfld     int32 OutOptionalTests::'outArg@10-1'
+    IL_002a:  ldsflda    int32 OutOptionalTests::'outArg@10-1'
+    IL_002f:  stloc.0
+    IL_0030:  ldloc.0
+    IL_0031:  ldc.i4.1
+    IL_0032:  stobj      [runtime]System.Int32
+    IL_0037:  ldc.i4.0
+    IL_0038:  call       int32 OutOptionalTests::'get_outArg@10-1'()
+    IL_003d:  newobj     instance void class [runtime]System.Tuple`2<bool,int32>::.ctor(!0,
+                                                                                         !1)
+    IL_0042:  stsfld     class [runtime]System.Tuple`2<bool,int32> OutOptionalTests::'patternInput@10-1'
+    IL_0047:  ret
+  } 
+
+  .property class [runtime]System.Tuple`2<bool,int32>
+          patternInput@9()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<bool,int32> OutOptionalTests::get_patternInput@9()
+  } 
+  .property int32 outArg@9()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .set void OutOptionalTests::set_outArg@9(int32)
+    .get int32 OutOptionalTests::get_outArg@9()
+  } 
+  .property class [runtime]System.Tuple`2<bool,int32>
+          'patternInput@10-1'()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<bool,int32> OutOptionalTests::'get_patternInput@10-1'()
+  } 
+  .property int32 'outArg@10-1'()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .set void OutOptionalTests::'set_outArg@10-1'(int32)
+    .get int32 OutOptionalTests::'get_outArg@10-1'()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$OutOptionalTests
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void OutOptionalTests::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+        """]
+
     [<Fact>]
     let ``Method with optional and out parameters resolves correctly (examples from original issue: https://github.com/dotnet/fsharp/issues/12515)`` () =
         Fsx """
diff --git a/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/StaticLet/StaticLetInGenericRecords.fs b/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/StaticLet/StaticLetInGenericRecords.fs
index 32e090ebdbf..4facec5630e 100644
--- a/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/StaticLet/StaticLetInGenericRecords.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/StaticLet/StaticLetInGenericRecords.fs
@@ -7,7 +7,7 @@ type MyRecord<'T> =
     }
 
     static let sizeOfT = sizeof<'T>
-    static let cachedVal = 
+    static let cachedVal =
         printfn "Creating cached val for %s" (typeof<'T>.Name)
         { X = Unchecked.defaultof<'T> ; Y = 15}
     static let mutable perTyparInstMutableCounter = 0
diff --git a/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/StaticLet/StaticLetInGenericRecordsILtest.fs b/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/StaticLet/StaticLetInGenericRecordsILtest.fs
index 738bd09f0fd..ef2414db2ed 100644
--- a/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/StaticLet/StaticLetInGenericRecordsILtest.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/StaticLet/StaticLetInGenericRecordsILtest.fs
@@ -9,7 +9,7 @@ type MyRecord<'T> =
         X: 'T 
     }
     // Init per typar
-    static let cachedVal =         
+    static let cachedVal =
         Console.WriteLine(typeof<'T>.Name)
         typeof<'T>.Name
 
diff --git a/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/StaticLet/StaticLetInUnionsAndRecords.fs b/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/StaticLet/StaticLetInUnionsAndRecords.fs
index 257fb1eeab3..17c7c03c808 100644
--- a/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/StaticLet/StaticLetInUnionsAndRecords.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/StaticLet/StaticLetInUnionsAndRecords.fs
@@ -396,7 +396,7 @@ Case2 1"""
    
 
 [<Fact>]
-let ``Static let IL init single file test`` () = 
+let ``Static let IL init single file test withRealInternalSignatureOff`` () = 
     FSharp """
 module Test
 open System
@@ -408,6 +408,7 @@ type X =
 do Console.WriteLine("module after type")
 """
     |> withLangVersion80
+    |> withRealInternalSignatureOff
     |> compile
     |> shouldSucceed
     |> verifyIL ["""
@@ -461,7 +462,99 @@ do Console.WriteLine("module after type")
 }"""]
 
 [<Fact>]
-let ``Static let in penultimate file IL test`` () =
+let ``Static let IL init single file test withRealInternalSignatureOn`` () = 
+    FSharp """
+module Test
+open System
+
+do Console.WriteLine("module before type")
+[<NoEquality;NoComparison>]
+type X =
+    static do Console.WriteLine("from type")
+do Console.WriteLine("module after type")
+"""
+    |> withLangVersion80
+    |> withRealInternalSignatureOn
+    |> compile
+    |> shouldSucceed
+    |> verifyIL ["""
+.class public abstract auto ansi sealed Test
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public X
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.NoEqualityAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.NoComparisonAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Test::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Test::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldstr      "from type"
+      IL_0005:  call       void [runtime]System.Console::WriteLine(string)
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Test::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Test::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldstr      "module before type"
+    IL_0005:  call       void [runtime]System.Console::WriteLine(string)
+    IL_000a:  call       void Test/X::staticInitialization@()
+    IL_000f:  ldstr      "module after type"
+    IL_0014:  call       void [runtime]System.Console::WriteLine(string)
+    IL_0019:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Test
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void Test::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+"""]
+
+[<Fact>]
+let ``Static let in penultimate file IL test withRealInternalSignatureOff`` () =
     let types = """
 namespace MyTypes
 open System
@@ -483,6 +576,7 @@ Console.Write(MyTypes.X.GetX)
     FSharp types
     |> withAdditionalSourceFiles [SourceCodeFileKind.Create("program.fs", program)]
     |> withLangVersion80
+    |> withRealInternalSignatureOff
     |> compile
     |> shouldSucceed
     |> verifyIL ["""
@@ -578,6 +672,148 @@ Console.Write(MyTypes.X.GetX)
 
 }"""]
 
+[<Fact>]
+let ``Static let in penultimate file IL test withRealInternalSignatureOn`` () =
+    let types = """
+namespace MyTypes
+open System
+
+[<NoEquality;NoComparison>]
+type X =
+    static do Console.WriteLine("from type")
+    static let mutable x_value = 42
+    static member GetX = x_value
+
+"""
+
+    let program = """
+module ProgramMain
+open System
+Console.Write(MyTypes.X.GetX)
+"""
+
+    FSharp types
+    |> withAdditionalSourceFiles [SourceCodeFileKind.Create("program.fs", program)]
+    |> withLangVersion80
+    |> withRealInternalSignatureOn
+    |> compile
+    |> shouldSucceed
+    |> verifyIL ["""
+.class public auto ansi serializable MyTypes.X
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.NoEqualityAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.NoComparisonAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .field static assembly int32 x_value
+  .field static assembly int32 init@6
+  .method public specialname static int32 get_GetX() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  volatile.
+    IL_0002:  ldsfld     int32 MyTypes.X::init@6
+    IL_0007:  ldc.i4.0
+    IL_0008:  bge.s      IL_0011
+
+    IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+    IL_000f:  br.s       IL_0011
+
+    IL_0011:  ldsfld     int32 MyTypes.X::x_value
+    IL_0016:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Test::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Test::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldstr      "from type"
+    IL_0005:  call       void [runtime]System.Console::WriteLine(string)
+    IL_000a:  ldc.i4.s   42
+    IL_000c:  stsfld     int32 MyTypes.X::x_value
+    IL_0011:  ldc.i4.0
+    IL_0012:  volatile.
+    IL_0014:  stsfld     int32 MyTypes.X::init@6
+    IL_0019:  ret
+  } 
+
+  .property int32 GetX()
+  {
+    .get int32 MyTypes.X::get_GetX()
+  } 
+} 
+
+.class public abstract auto ansi sealed ProgramMain
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$ProgramMain::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$ProgramMain::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       int32 MyTypes.X::get_GetX()
+    IL_0005:  call       void [runtime]System.Console::Write(int32)
+    IL_000a:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$ProgramMain
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void ProgramMain::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Test
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void MyTypes.X::staticInitialization@()
+    IL_0005:  ret
+  }
+"""]
+
+
 [<Theory>]
 [<InlineData("preview")>]
 let ``Regression 16009 - module rec does not initialize let bindings`` langVersion =
diff --git a/tests/FSharp.Compiler.ComponentTests/Conformance/InferenceProcedures/RecursiveSafetyAnalysis/RecursiveSafetyAnalysis.fs b/tests/FSharp.Compiler.ComponentTests/Conformance/InferenceProcedures/RecursiveSafetyAnalysis/RecursiveSafetyAnalysis.fs
index 52bf8601869..9b9beecfdb0 100644
--- a/tests/FSharp.Compiler.ComponentTests/Conformance/InferenceProcedures/RecursiveSafetyAnalysis/RecursiveSafetyAnalysis.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Conformance/InferenceProcedures/RecursiveSafetyAnalysis/RecursiveSafetyAnalysis.fs
@@ -49,7 +49,7 @@ module RecursiveSafetyAnalysis =
             (Error 1114, Line 8, Col 15, Line 8, Col 25, "The value 'E_RecursiveInline.test' was marked inline but was not bound in the optimization environment")
             (Error 1113, Line 7, Col 16, Line 7, Col 20, "The value 'test' was marked inline but its implementation makes use of an internal or private function which is not sufficiently accessible")
             (Warning 1116, Line 8, Col 15, Line 8, Col 25, "A value marked as 'inline' has an unexpected value")
-            (Error 1118, Line 8, Col 15, Line 8, Col 25, "Failed to inline the value 'test' marked 'inline', perhaps because a recursive value was marked 'inline'")
+            (Warning 1118, Line 8, Col 15, Line 8, Col 25, "Failed to inline the value 'test' marked 'inline', perhaps because a recursive value was marked 'inline'")
         ]
 
     // SOURCE=E_TypeDeclaration01.fs SCFLAGS="--langversion:5.0 --test:ErrorRanges" COMPILE_ONLY=1	# E_TypeDeclaration01.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionStepping.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionStepping.fs
index 9f5b523b944..89c1c62c7c0 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionStepping.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionStepping.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open Xunit
 open FSharp.Test
@@ -17,28 +17,74 @@ module AsyncExpressionStepping =
         |> verifyBaseline
         |> verifyILBaseline
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"AsyncExpressionSteppingTest1.fs"|])>]
-    let ``AsyncExpressionSteppingTest1_fs`` compilation =
-        verifyCompilation compilation
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"AsyncExpressionSteppingTest1.fs"|])>]
+    let ``AsyncExpressionSteppingTest1_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"AsyncExpressionSteppingTest1.fs"|])>]
+    let ``AsyncExpressionSteppingTest1_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"AsyncExpressionSteppingTest2.fs"|])>]
+    let ``AsyncExpressionSteppingTest2_RealInternalSignatureOnfs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"AsyncExpressionSteppingTest2.fs"|])>]
+    let ``AsyncExpressionSteppingTest2_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"AsyncExpressionSteppingTest3.fs"|])>]
+    let ``AsyncExpressionSteppingTest3_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"AsyncExpressionSteppingTest2.fs"|])>]
-    let ``AsyncExpressionSteppingTest2_fs`` compilation =
-        verifyCompilation compilation
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"AsyncExpressionSteppingTest3.fs"|])>]
+    let ``AsyncExpressionSteppingTest3_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"AsyncExpressionSteppingTest3.fs"|])>]
-    let ``AsyncExpressionSteppingTest3_fs`` compilation =
-        verifyCompilation compilation
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"AsyncExpressionSteppingTest4.fs"|])>]
+    let ``AsyncExpressionSteppingTest4_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"AsyncExpressionSteppingTest4.fs"|])>]
-    let ``AsyncExpressionSteppingTest4_fs`` compilation =
-        verifyCompilation compilation
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"AsyncExpressionSteppingTest4.fs"|])>]
+    let ``AsyncExpressionSteppingTest4_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"AsyncExpressionSteppingTest5.fs"|])>]
-    let ``AsyncExpressionSteppingTest5_fs`` compilation =
-        verifyCompilation compilation
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"AsyncExpressionSteppingTest5.fs"|])>]
+    let ``AsyncExpressionSteppingTest5_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"AsyncExpressionSteppingTest6.fs"|])>]
-    let ``AsyncExpressionSteppingTest6_fs`` compilation =
-        verifyCompilation compilation
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"AsyncExpressionSteppingTest5.fs"|])>]
+    let ``AsyncExpressionSteppingTest5_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
 
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"AsyncExpressionSteppingTest6.fs"|])>]
+    let ``AsyncExpressionSteppingTest6_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
 
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"AsyncExpressionSteppingTest6.fs"|])>]
+    let ``AsyncExpressionSteppingTest6_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest1.fs.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest1.fs.RealInternalSignatureOff.il.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest1.fs.il.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest1.fs.RealInternalSignatureOff.il.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest1.fs.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest1.fs.RealInternalSignatureOff.il.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest1.fs.il.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest1.fs.RealInternalSignatureOff.il.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest1.fs.RealInternalSignatureOn.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest1.fs.RealInternalSignatureOn.il.debug.bsl
new file mode 100644
index 00000000000..b8ab856f75a
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest1.fs.RealInternalSignatureOn.il.debug.bsl
@@ -0,0 +1,186 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public assembly
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto ansi serializable sealed nested assembly beforefieldinit f1@6
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f1@6::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldstr      "hello"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_000f:  pop
+        IL_0010:  ldstr      "stuck in the middle"
+        IL_0015:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_001a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_001f:  pop
+        IL_0020:  ldstr      "goodbye"
+        IL_0025:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_002a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_002f:  pop
+        IL_0030:  ldarg.0
+        IL_0031:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f1@6::builder@
+        IL_0036:  tail.
+        IL_0038:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Zero()
+        IL_003d:  ret
+      } 
+
+    } 
+
+    .method public static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> f1() cil managed
+    {
+      
+      .maxstack  4
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_0)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  newobj     instance void assembly/assembly/f1@6::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+      IL_000d:  tail.
+      IL_000f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+      IL_0014:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_1)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly::f1()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  stloc.1
+      IL_0008:  ldloc.1
+      IL_0009:  ldnull
+      IL_000a:  ldnull
+      IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync::RunSynchronously<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<int32>,
+                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<valuetype [runtime]System.Threading.CancellationToken>)
+      IL_0010:  pop
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest1.fs.RealInternalSignatureOn.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest1.fs.RealInternalSignatureOn.il.release.bsl
new file mode 100644
index 00000000000..b8ab856f75a
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest1.fs.RealInternalSignatureOn.il.release.bsl
@@ -0,0 +1,186 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public assembly
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto ansi serializable sealed nested assembly beforefieldinit f1@6
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f1@6::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldstr      "hello"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_000f:  pop
+        IL_0010:  ldstr      "stuck in the middle"
+        IL_0015:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_001a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_001f:  pop
+        IL_0020:  ldstr      "goodbye"
+        IL_0025:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_002a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_002f:  pop
+        IL_0030:  ldarg.0
+        IL_0031:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f1@6::builder@
+        IL_0036:  tail.
+        IL_0038:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Zero()
+        IL_003d:  ret
+      } 
+
+    } 
+
+    .method public static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> f1() cil managed
+    {
+      
+      .maxstack  4
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_0)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  newobj     instance void assembly/assembly/f1@6::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+      IL_000d:  tail.
+      IL_000f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+      IL_0014:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_1)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly::f1()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  stloc.1
+      IL_0008:  ldloc.1
+      IL_0009:  ldnull
+      IL_000a:  ldnull
+      IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync::RunSynchronously<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<int32>,
+                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<valuetype [runtime]System.Threading.CancellationToken>)
+      IL_0010:  pop
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest2.fs.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest2.fs.RealInternalSignatureOff.il.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest2.fs.il.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest2.fs.RealInternalSignatureOff.il.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest2.fs.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest2.fs.RealInternalSignatureOff.il.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest2.fs.il.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest2.fs.RealInternalSignatureOff.il.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest2.fs.RealInternalSignatureOn.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest2.fs.RealInternalSignatureOn.il.debug.bsl
new file mode 100644
index 00000000000..39b879bc70a
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest2.fs.RealInternalSignatureOn.il.debug.bsl
@@ -0,0 +1,284 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public assembly
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f2@6-1'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,bool>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,bool>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f2@6-1'::x
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance bool Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f2@6-1'::x
+        IL_0006:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_000b:  ldc.i4.4
+        IL_000c:  clt
+        IL_000e:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f2@7-2'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x,
+                                   class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f2@7-2'::x
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f2@7-2'::builder@
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f2@7-2'::x
+        IL_0006:  ldarg.0
+        IL_0007:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f2@7-2'::x
+        IL_000c:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0011:  ldc.i4.1
+        IL_0012:  add
+        IL_0013:  callvirt   instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_Value(!0)
+        IL_0018:  nop
+        IL_0019:  ldstr      "hello"
+        IL_001e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_0023:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0028:  pop
+        IL_0029:  ldarg.0
+        IL_002a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f2@7-2'::builder@
+        IL_002f:  tail.
+        IL_0031:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Zero()
+        IL_0036:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit f2@6
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x,
+                                   class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/f2@6::x
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f2@6::builder@
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  9
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f2@6::builder@
+        IL_0006:  ldarg.0
+        IL_0007:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/f2@6::x
+        IL_000c:  newobj     instance void assembly/assembly/'f2@6-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>)
+        IL_0011:  ldarg.0
+        IL_0012:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f2@6::builder@
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/f2@6::x
+        IL_001d:  ldarg.0
+        IL_001e:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f2@6::builder@
+        IL_0023:  newobj     instance void assembly/assembly/'f2@7-2'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>,
+                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+        IL_0028:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+        IL_002d:  tail.
+        IL_002f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::While(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,bool>,
+                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0034:  ret
+      } 
+
+    } 
+
+    .method public static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> f2() cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_1)
+      IL_0000:  ldc.i4.0
+      IL_0001:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::Ref<int32>(!!0)
+      IL_0006:  stloc.0
+      IL_0007:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+      IL_000c:  stloc.1
+      IL_000d:  ldloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  newobj     instance void assembly/assembly/f2@6::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>,
+                                                                                                               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+      IL_0015:  tail.
+      IL_0017:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+      IL_001c:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_1)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly::f2()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  stloc.1
+      IL_0008:  ldloc.1
+      IL_0009:  ldnull
+      IL_000a:  ldnull
+      IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync::RunSynchronously<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<int32>,
+                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<valuetype [runtime]System.Threading.CancellationToken>)
+      IL_0010:  pop
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest2.fs.RealInternalSignatureOn.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest2.fs.RealInternalSignatureOn.il.release.bsl
new file mode 100644
index 00000000000..39b879bc70a
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest2.fs.RealInternalSignatureOn.il.release.bsl
@@ -0,0 +1,284 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public assembly
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f2@6-1'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,bool>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,bool>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f2@6-1'::x
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance bool Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f2@6-1'::x
+        IL_0006:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_000b:  ldc.i4.4
+        IL_000c:  clt
+        IL_000e:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f2@7-2'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x,
+                                   class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f2@7-2'::x
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f2@7-2'::builder@
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f2@7-2'::x
+        IL_0006:  ldarg.0
+        IL_0007:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f2@7-2'::x
+        IL_000c:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0011:  ldc.i4.1
+        IL_0012:  add
+        IL_0013:  callvirt   instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_Value(!0)
+        IL_0018:  nop
+        IL_0019:  ldstr      "hello"
+        IL_001e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_0023:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0028:  pop
+        IL_0029:  ldarg.0
+        IL_002a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f2@7-2'::builder@
+        IL_002f:  tail.
+        IL_0031:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Zero()
+        IL_0036:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit f2@6
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x,
+                                   class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/f2@6::x
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f2@6::builder@
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  9
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f2@6::builder@
+        IL_0006:  ldarg.0
+        IL_0007:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/f2@6::x
+        IL_000c:  newobj     instance void assembly/assembly/'f2@6-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>)
+        IL_0011:  ldarg.0
+        IL_0012:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f2@6::builder@
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/f2@6::x
+        IL_001d:  ldarg.0
+        IL_001e:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f2@6::builder@
+        IL_0023:  newobj     instance void assembly/assembly/'f2@7-2'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>,
+                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+        IL_0028:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+        IL_002d:  tail.
+        IL_002f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::While(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,bool>,
+                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0034:  ret
+      } 
+
+    } 
+
+    .method public static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> f2() cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_1)
+      IL_0000:  ldc.i4.0
+      IL_0001:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::Ref<int32>(!!0)
+      IL_0006:  stloc.0
+      IL_0007:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+      IL_000c:  stloc.1
+      IL_000d:  ldloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  newobj     instance void assembly/assembly/f2@6::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>,
+                                                                                                               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+      IL_0015:  tail.
+      IL_0017:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+      IL_001c:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_1)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly::f2()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  stloc.1
+      IL_0008:  ldloc.1
+      IL_0009:  ldnull
+      IL_000a:  ldnull
+      IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync::RunSynchronously<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<int32>,
+                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<valuetype [runtime]System.Threading.CancellationToken>)
+      IL_0010:  pop
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest3.fs.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest3.fs.RealInternalSignatureOff.il.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest3.fs.il.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest3.fs.RealInternalSignatureOff.il.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest3.fs.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest3.fs.RealInternalSignatureOff.il.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest3.fs.il.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest3.fs.RealInternalSignatureOff.il.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest3.fs.RealInternalSignatureOn.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest3.fs.RealInternalSignatureOn.il.debug.bsl
new file mode 100644
index 00000000000..a6484ab298b
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest3.fs.RealInternalSignatureOn.il.debug.bsl
@@ -0,0 +1,249 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public assembly
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@10-1'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public int32 res
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 res) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 assembly/assembly/'f3@10-1'::res
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      int32 assembly/assembly/'f3@10-1'::res
+        IL_0007:  tail.
+        IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>::Success(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!0>,
+                                                                                                                                                                       !0)
+        IL_000e:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit f3@5
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f3@5::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_0,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_1,
+                 int32 V_2,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_3,
+                 int32 V_4,
+                 int32 V_5)
+        IL_0000:  ldc.i4.0
+        IL_0001:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::Ref<int32>(!!0)
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_000e:  ldc.i4.1
+        IL_000f:  add
+        IL_0010:  callvirt   instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_Value(!0)
+        IL_0015:  nop
+        IL_0016:  ldc.i4.0
+        IL_0017:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::Ref<int32>(!!0)
+        IL_001c:  stloc.1
+        IL_001d:  ldloc.1
+        IL_001e:  ldloc.1
+        IL_001f:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0024:  ldc.i4.1
+        IL_0025:  add
+        IL_0026:  callvirt   instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_Value(!0)
+        IL_002b:  nop
+        IL_002c:  ldloc.0
+        IL_002d:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0032:  ldloc.0
+        IL_0033:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0038:  add
+        IL_0039:  stloc.2
+        IL_003a:  ldarg.0
+        IL_003b:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f3@5::builder@
+        IL_0040:  stloc.3
+        IL_0041:  ldloc.2
+        IL_0042:  stloc.s    V_4
+        IL_0044:  ldloc.s    V_4
+        IL_0046:  stloc.s    V_5
+        IL_0048:  ldloc.s    V_5
+        IL_004a:  newobj     instance void assembly/assembly/'f3@10-1'::.ctor(int32)
+        IL_004f:  tail.
+        IL_0051:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_0056:  ret
+      } 
+
+    } 
+
+    .method public static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> f3() cil managed
+    {
+      
+      .maxstack  4
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_0)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  newobj     instance void assembly/assembly/f3@5::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+      IL_000d:  tail.
+      IL_000f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+      IL_0014:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_1)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly::f3()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  stloc.1
+      IL_0008:  ldloc.1
+      IL_0009:  ldnull
+      IL_000a:  ldnull
+      IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync::RunSynchronously<int32>(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<int32>,
+                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<valuetype [runtime]System.Threading.CancellationToken>)
+      IL_0010:  pop
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest3.fs.RealInternalSignatureOn.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest3.fs.RealInternalSignatureOn.il.release.bsl
new file mode 100644
index 00000000000..ebae270051a
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest3.fs.RealInternalSignatureOn.il.release.bsl
@@ -0,0 +1,246 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public assembly
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@10-1'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public int32 'value'
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 'value') cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 assembly/assembly/'f3@10-1'::'value'
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      int32 assembly/assembly/'f3@10-1'::'value'
+        IL_0007:  tail.
+        IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>::Success(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!0>,
+                                                                                                                                                                       !0)
+        IL_000e:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit f3@5
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f3@5::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_0,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_1,
+                 int32 V_2,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_3,
+                 int32 V_4)
+        IL_0000:  ldc.i4.0
+        IL_0001:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::Ref<int32>(!!0)
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_000e:  ldc.i4.1
+        IL_000f:  add
+        IL_0010:  callvirt   instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_Value(!0)
+        IL_0015:  nop
+        IL_0016:  ldc.i4.0
+        IL_0017:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::Ref<int32>(!!0)
+        IL_001c:  stloc.1
+        IL_001d:  ldloc.1
+        IL_001e:  ldloc.1
+        IL_001f:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0024:  ldc.i4.1
+        IL_0025:  add
+        IL_0026:  callvirt   instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_Value(!0)
+        IL_002b:  nop
+        IL_002c:  ldloc.0
+        IL_002d:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0032:  ldloc.0
+        IL_0033:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0038:  add
+        IL_0039:  stloc.2
+        IL_003a:  ldarg.0
+        IL_003b:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f3@5::builder@
+        IL_0040:  stloc.3
+        IL_0041:  ldloc.2
+        IL_0042:  stloc.s    V_4
+        IL_0044:  ldloc.s    V_4
+        IL_0046:  newobj     instance void assembly/assembly/'f3@10-1'::.ctor(int32)
+        IL_004b:  tail.
+        IL_004d:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_0052:  ret
+      } 
+
+    } 
+
+    .method public static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> f3() cil managed
+    {
+      
+      .maxstack  4
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_0)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  newobj     instance void assembly/assembly/f3@5::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+      IL_000d:  tail.
+      IL_000f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+      IL_0014:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_1)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly::f3()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  stloc.1
+      IL_0008:  ldloc.1
+      IL_0009:  ldnull
+      IL_000a:  ldnull
+      IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync::RunSynchronously<int32>(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<int32>,
+                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<valuetype [runtime]System.Threading.CancellationToken>)
+      IL_0010:  pop
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest4.fs.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest4.fs.RealInternalSignatureOff.il.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest4.fs.il.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest4.fs.RealInternalSignatureOff.il.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest4.fs.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest4.fs.RealInternalSignatureOff.il.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest4.fs.il.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest4.fs.RealInternalSignatureOff.il.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest4.fs.RealInternalSignatureOn.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest4.fs.RealInternalSignatureOn.il.debug.bsl
new file mode 100644
index 00000000000..968ce31a441
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest4.fs.RealInternalSignatureOn.il.debug.bsl
@@ -0,0 +1,395 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public assembly
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f4@10-2'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public int32 res
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 res) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 assembly/assembly/'f4@10-2'::res
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      int32 assembly/assembly/'f4@10-2'::res
+        IL_0007:  tail.
+        IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>::Success(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!0>,
+                                                                                                                                                                       !0)
+        IL_000e:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f4@7-1'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f4@7-1'::builder@
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f4@7-1'::x
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  6
+        .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_0,
+                 int32 V_1,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_2,
+                 int32 V_3,
+                 int32 V_4)
+        IL_0000:  nop
+        IL_0001:  ldc.i4.0
+        IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::Ref<int32>(!!0)
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  ldloc.0
+        IL_000a:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_000f:  callvirt   instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_Value(!0)
+        IL_0014:  nop
+        IL_0015:  ldarg.0
+        IL_0016:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f4@7-1'::x
+        IL_001b:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0020:  ldloc.0
+        IL_0021:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0026:  add
+        IL_0027:  stloc.1
+        IL_0028:  ldarg.0
+        IL_0029:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f4@7-1'::builder@
+        IL_002e:  stloc.2
+        IL_002f:  ldloc.1
+        IL_0030:  stloc.3
+        IL_0031:  ldloc.3
+        IL_0032:  stloc.s    V_4
+        IL_0034:  ldloc.s    V_4
+        IL_0036:  newobj     instance void assembly/assembly/'f4@10-2'::.ctor(int32)
+        IL_003b:  tail.
+        IL_003d:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_0042:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f4@12-3'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f4@12-3'::x
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.Unit Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  nop
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f4@12-3'::x
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f4@12-3'::x
+        IL_000d:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0012:  callvirt   instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_Value(!0)
+        IL_0017:  nop
+        IL_0018:  ldstr      "done"
+        IL_001d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_0022:  tail.
+        IL_0024:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0029:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f4@6-4'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> finallyFunction
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> computation
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> finallyFunction,
+                                   class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> computation) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly/'f4@6-4'::finallyFunction
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f4@6-4'::computation
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f4@6-4'::computation
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly/'f4@6-4'::finallyFunction
+        IL_000d:  tail.
+        IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::TryFinally<int32>(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0014:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit f4@5
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f4@5::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_0,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_1,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_2,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_3,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_4,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_5)
+        IL_0000:  ldc.i4.0
+        IL_0001:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::Ref<int32>(!!0)
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f4@5::builder@
+        IL_000d:  stloc.1
+        IL_000e:  ldarg.0
+        IL_000f:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f4@5::builder@
+        IL_0014:  ldarg.0
+        IL_0015:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f4@5::builder@
+        IL_001a:  ldloc.0
+        IL_001b:  newobj     instance void assembly/assembly/'f4@7-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder,
+                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>)
+        IL_0020:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+        IL_0025:  stloc.2
+        IL_0026:  ldloc.0
+        IL_0027:  newobj     instance void assembly/assembly/'f4@12-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>)
+        IL_002c:  stloc.3
+        IL_002d:  ldloc.3
+        IL_002e:  stloc.s    V_4
+        IL_0030:  ldloc.2
+        IL_0031:  stloc.s    V_5
+        IL_0033:  ldloc.s    V_4
+        IL_0035:  ldloc.s    V_5
+        IL_0037:  newobj     instance void assembly/assembly/'f4@6-4'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,
+                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>)
+        IL_003c:  tail.
+        IL_003e:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_0043:  ret
+      } 
+
+    } 
+
+    .method public static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> f4() cil managed
+    {
+      
+      .maxstack  4
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_0)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  newobj     instance void assembly/assembly/f4@5::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+      IL_000d:  tail.
+      IL_000f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+      IL_0014:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_1)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly::f4()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  stloc.1
+      IL_0008:  ldloc.1
+      IL_0009:  ldnull
+      IL_000a:  ldnull
+      IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync::RunSynchronously<int32>(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<int32>,
+                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<valuetype [runtime]System.Threading.CancellationToken>)
+      IL_0010:  pop
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest4.fs.RealInternalSignatureOn.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest4.fs.RealInternalSignatureOn.il.release.bsl
new file mode 100644
index 00000000000..222deea406e
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest4.fs.RealInternalSignatureOn.il.release.bsl
@@ -0,0 +1,386 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public assembly
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f4@10-2'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public int32 'value'
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 'value') cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 assembly/assembly/'f4@10-2'::'value'
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      int32 assembly/assembly/'f4@10-2'::'value'
+        IL_0007:  tail.
+        IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>::Success(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!0>,
+                                                                                                                                                                       !0)
+        IL_000e:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f4@7-1'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f4@7-1'::builder@
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f4@7-1'::x
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  6
+        .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_0,
+                 int32 V_1,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_2,
+                 int32 V_3)
+        IL_0000:  nop
+        IL_0001:  ldc.i4.0
+        IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::Ref<int32>(!!0)
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  ldloc.0
+        IL_000a:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_000f:  callvirt   instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_Value(!0)
+        IL_0014:  nop
+        IL_0015:  ldarg.0
+        IL_0016:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f4@7-1'::x
+        IL_001b:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0020:  ldloc.0
+        IL_0021:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0026:  add
+        IL_0027:  stloc.1
+        IL_0028:  ldarg.0
+        IL_0029:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f4@7-1'::builder@
+        IL_002e:  stloc.2
+        IL_002f:  ldloc.1
+        IL_0030:  stloc.3
+        IL_0031:  ldloc.3
+        IL_0032:  newobj     instance void assembly/assembly/'f4@10-2'::.ctor(int32)
+        IL_0037:  tail.
+        IL_0039:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_003e:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f4@12-3'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f4@12-3'::x
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.Unit Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  nop
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f4@12-3'::x
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f4@12-3'::x
+        IL_000d:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0012:  callvirt   instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_Value(!0)
+        IL_0017:  nop
+        IL_0018:  ldstr      "done"
+        IL_001d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_0022:  tail.
+        IL_0024:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0029:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f4@6-4'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> computation
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> compensation
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> computation,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> compensation) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f4@6-4'::computation
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly/'f4@6-4'::compensation
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f4@6-4'::computation
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly/'f4@6-4'::compensation
+        IL_000d:  tail.
+        IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::TryFinally<int32>(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0014:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit f4@5
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f4@5::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_0,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_1,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_2,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_3)
+        IL_0000:  ldc.i4.0
+        IL_0001:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::Ref<int32>(!!0)
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f4@5::builder@
+        IL_000d:  stloc.1
+        IL_000e:  ldarg.0
+        IL_000f:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f4@5::builder@
+        IL_0014:  ldarg.0
+        IL_0015:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f4@5::builder@
+        IL_001a:  ldloc.0
+        IL_001b:  newobj     instance void assembly/assembly/'f4@7-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder,
+                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>)
+        IL_0020:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+        IL_0025:  stloc.2
+        IL_0026:  ldloc.0
+        IL_0027:  newobj     instance void assembly/assembly/'f4@12-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>)
+        IL_002c:  stloc.3
+        IL_002d:  ldloc.2
+        IL_002e:  ldloc.3
+        IL_002f:  newobj     instance void assembly/assembly/'f4@6-4'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>,
+                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0034:  tail.
+        IL_0036:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_003b:  ret
+      } 
+
+    } 
+
+    .method public static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> f4() cil managed
+    {
+      
+      .maxstack  4
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_0)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  newobj     instance void assembly/assembly/f4@5::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+      IL_000d:  tail.
+      IL_000f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+      IL_0014:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_1)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly::f4()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  stloc.1
+      IL_0008:  ldloc.1
+      IL_0009:  ldnull
+      IL_000a:  ldnull
+      IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync::RunSynchronously<int32>(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<int32>,
+                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<valuetype [runtime]System.Threading.CancellationToken>)
+      IL_0010:  pop
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest5.fs.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest5.fs.RealInternalSignatureOff.il.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest5.fs.il.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest5.fs.RealInternalSignatureOff.il.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest5.fs.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest5.fs.RealInternalSignatureOff.il.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest5.fs.il.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest5.fs.RealInternalSignatureOff.il.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest5.fs.RealInternalSignatureOn.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest5.fs.RealInternalSignatureOn.il.debug.bsl
new file mode 100644
index 00000000000..2962a173205
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest5.fs.RealInternalSignatureOn.il.debug.bsl
@@ -0,0 +1,447 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public assembly
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f7@6-1'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f7@6-1'::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(int32 _arg1) cil managed
+      {
+        
+        .maxstack  5
+        .locals init (int32 V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  stloc.0
+        IL_0002:  ldstr      "hello"
+        IL_0007:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_000c:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0011:  pop
+        IL_0012:  ldstr      "hello 2"
+        IL_0017:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_001c:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0021:  pop
+        IL_0022:  ldarg.0
+        IL_0023:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f7@6-1'::builder@
+        IL_0028:  tail.
+        IL_002a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Zero()
+        IL_002f:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f7@9-3'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f7@9-3'::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(int32 _arg2) cil managed
+      {
+        
+        .maxstack  5
+        .locals init (int32 V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  stloc.0
+        IL_0002:  ldstr      "goodbye"
+        IL_0007:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_000c:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0011:  pop
+        IL_0012:  ldstr      "goodbye 2"
+        IL_0017:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_001c:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0021:  pop
+        IL_0022:  ldarg.0
+        IL_0023:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f7@9-3'::builder@
+        IL_0028:  tail.
+        IL_002a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Zero()
+        IL_002f:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f7@9-2'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f7@9-2'::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f7@9-2'::builder@
+        IL_0006:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly/assembly::get_es()
+        IL_000b:  ldarg.0
+        IL_000c:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f7@9-2'::builder@
+        IL_0011:  newobj     instance void assembly/assembly/'f7@9-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+        IL_0016:  tail.
+        IL_0018:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::For<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>)
+        IL_001d:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f7@6-4'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> part2
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> part2) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly/'f7@6-4'::part2
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly/'f7@6-4'::part2
+        IL_0006:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f7@6-5'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> part1
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>> part2
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> part1,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>> part2) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly/'f7@6-5'::part1
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>> assembly/assembly/'f7@6-5'::part2
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly/'f7@6-5'::part1
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>> assembly/assembly/'f7@6-5'::part2
+        IL_000d:  tail.
+        IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::Bind<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,
+                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!1>,
+                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!1,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+        IL_0014:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit f7@6
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f7@6::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_0,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_1,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_2,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_3,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_4,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_5,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>> V_6)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f7@6::builder@
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f7@6::builder@
+        IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly/assembly::get_es()
+        IL_0012:  ldarg.0
+        IL_0013:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f7@6::builder@
+        IL_0018:  newobj     instance void assembly/assembly/'f7@6-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+        IL_001d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::For<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>)
+        IL_0022:  stloc.1
+        IL_0023:  ldarg.0
+        IL_0024:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f7@6::builder@
+        IL_0029:  ldarg.0
+        IL_002a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f7@6::builder@
+        IL_002f:  newobj     instance void assembly/assembly/'f7@9-2'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+        IL_0034:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+        IL_0039:  stloc.2
+        IL_003a:  ldloc.1
+        IL_003b:  stloc.3
+        IL_003c:  ldloc.2
+        IL_003d:  stloc.s    V_4
+        IL_003f:  ldloc.3
+        IL_0040:  stloc.s    V_5
+        IL_0042:  ldloc.s    V_4
+        IL_0044:  newobj     instance void assembly/assembly/'f7@6-4'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0049:  stloc.s    V_6
+        IL_004b:  ldloc.s    V_5
+        IL_004d:  ldloc.s    V_6
+        IL_004f:  newobj     instance void assembly/assembly/'f7@6-5'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>,
+                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>)
+        IL_0054:  tail.
+        IL_0056:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_005b:  ret
+      } 
+
+    } 
+
+    .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> es@4
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_es() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly/assembly::es@4
+      IL_0005:  ret
+    } 
+
+    .method public static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> f7() cil managed
+    {
+      
+      .maxstack  4
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_0)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  newobj     instance void assembly/assembly/f7@6::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+      IL_000d:  tail.
+      IL_000f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+      IL_0014:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_1)
+      IL_0000:  ldc.i4.3
+      IL_0001:  ldc.i4.4
+      IL_0002:  ldc.i4.5
+      IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+      IL_0008:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_0017:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly/assembly::es@4
+      IL_001c:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly::f7()
+      IL_0021:  stloc.0
+      IL_0022:  ldloc.0
+      IL_0023:  stloc.1
+      IL_0024:  ldloc.1
+      IL_0025:  ldnull
+      IL_0026:  ldnull
+      IL_0027:  call       !!0 [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync::RunSynchronously<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<int32>,
+                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<valuetype [runtime]System.Threading.CancellationToken>)
+      IL_002c:  pop
+      IL_002d:  ret
+    } 
+
+    .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+            es()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+      .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly/assembly::get_es()
+    } 
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest5.fs.RealInternalSignatureOn.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest5.fs.RealInternalSignatureOn.il.release.bsl
new file mode 100644
index 00000000000..7690231f5e1
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest5.fs.RealInternalSignatureOn.il.release.bsl
@@ -0,0 +1,438 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public assembly
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f7@6-1'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f7@6-1'::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(int32 _arg1) cil managed
+      {
+        
+        .maxstack  5
+        .locals init (int32 V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  stloc.0
+        IL_0002:  ldstr      "hello"
+        IL_0007:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_000c:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0011:  pop
+        IL_0012:  ldstr      "hello 2"
+        IL_0017:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_001c:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0021:  pop
+        IL_0022:  ldarg.0
+        IL_0023:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f7@6-1'::builder@
+        IL_0028:  tail.
+        IL_002a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Zero()
+        IL_002f:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f7@9-3'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f7@9-3'::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(int32 _arg2) cil managed
+      {
+        
+        .maxstack  5
+        .locals init (int32 V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  stloc.0
+        IL_0002:  ldstr      "goodbye"
+        IL_0007:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_000c:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0011:  pop
+        IL_0012:  ldstr      "goodbye 2"
+        IL_0017:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_001c:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0021:  pop
+        IL_0022:  ldarg.0
+        IL_0023:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f7@9-3'::builder@
+        IL_0028:  tail.
+        IL_002a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Zero()
+        IL_002f:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f7@9-2'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f7@9-2'::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f7@9-2'::builder@
+        IL_0006:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly/assembly::get_es()
+        IL_000b:  ldarg.0
+        IL_000c:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f7@9-2'::builder@
+        IL_0011:  newobj     instance void assembly/assembly/'f7@9-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+        IL_0016:  tail.
+        IL_0018:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::For<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>)
+        IL_001d:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f7@6-4'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> computation2
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> computation2) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly/'f7@6-4'::computation2
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly/'f7@6-4'::computation2
+        IL_0006:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f7@6-5'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> computation1
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>> part2
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> computation1,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>> part2) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly/'f7@6-5'::computation1
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>> assembly/assembly/'f7@6-5'::part2
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly/'f7@6-5'::computation1
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>> assembly/assembly/'f7@6-5'::part2
+        IL_000d:  tail.
+        IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::Bind<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,
+                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!1>,
+                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!1,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+        IL_0014:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit f7@6
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f7@6::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_0,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_1,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_2,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>> V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f7@6::builder@
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f7@6::builder@
+        IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly/assembly::get_es()
+        IL_0012:  ldarg.0
+        IL_0013:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f7@6::builder@
+        IL_0018:  newobj     instance void assembly/assembly/'f7@6-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+        IL_001d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::For<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>)
+        IL_0022:  stloc.1
+        IL_0023:  ldarg.0
+        IL_0024:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f7@6::builder@
+        IL_0029:  ldarg.0
+        IL_002a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f7@6::builder@
+        IL_002f:  newobj     instance void assembly/assembly/'f7@9-2'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+        IL_0034:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+        IL_0039:  stloc.2
+        IL_003a:  ldloc.2
+        IL_003b:  newobj     instance void assembly/assembly/'f7@6-4'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0040:  stloc.3
+        IL_0041:  ldloc.1
+        IL_0042:  ldloc.3
+        IL_0043:  newobj     instance void assembly/assembly/'f7@6-5'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>,
+                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>)
+        IL_0048:  tail.
+        IL_004a:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_004f:  ret
+      } 
+
+    } 
+
+    .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> es@4
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_es() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly/assembly::es@4
+      IL_0005:  ret
+    } 
+
+    .method public static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> f7() cil managed
+    {
+      
+      .maxstack  4
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_0)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  newobj     instance void assembly/assembly/f7@6::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+      IL_000d:  tail.
+      IL_000f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+      IL_0014:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_1)
+      IL_0000:  ldc.i4.3
+      IL_0001:  ldc.i4.4
+      IL_0002:  ldc.i4.5
+      IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+      IL_0008:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_0017:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly/assembly::es@4
+      IL_001c:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> assembly/assembly::f7()
+      IL_0021:  stloc.0
+      IL_0022:  ldloc.0
+      IL_0023:  stloc.1
+      IL_0024:  ldloc.1
+      IL_0025:  ldnull
+      IL_0026:  ldnull
+      IL_0027:  call       !!0 [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync::RunSynchronously<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<int32>,
+                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<valuetype [runtime]System.Threading.CancellationToken>)
+      IL_002c:  pop
+      IL_002d:  ret
+    } 
+
+    .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+            es()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+      .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly/assembly::get_es()
+    } 
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest6.fs.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest6.fs.RealInternalSignatureOff.il.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest6.fs.il.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest6.fs.RealInternalSignatureOff.il.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest6.fs.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest6.fs.RealInternalSignatureOff.il.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest6.fs.il.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest6.fs.RealInternalSignatureOff.il.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest6.fs.RealInternalSignatureOn.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest6.fs.RealInternalSignatureOn.il.debug.bsl
new file mode 100644
index 00000000000..6565fbe138b
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest6.fs.RealInternalSignatureOn.il.debug.bsl
@@ -0,0 +1,818 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public assembly
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f2@10-1'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public int32 res
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 res) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 assembly/assembly/'f2@10-1'::res
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      int32 assembly/assembly/'f2@10-1'::res
+        IL_0007:  tail.
+        IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>::Success(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!0>,
+                                                                                                                                                                       !0)
+        IL_000e:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit f2@5
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f2@5::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_0,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_1,
+                 int32 V_2,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_3,
+                 int32 V_4,
+                 int32 V_5)
+        IL_0000:  ldc.i4.0
+        IL_0001:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::Ref<int32>(!!0)
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_000e:  ldc.i4.1
+        IL_000f:  add
+        IL_0010:  callvirt   instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_Value(!0)
+        IL_0015:  nop
+        IL_0016:  ldc.i4.0
+        IL_0017:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::Ref<int32>(!!0)
+        IL_001c:  stloc.1
+        IL_001d:  ldloc.1
+        IL_001e:  ldloc.1
+        IL_001f:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0024:  ldc.i4.1
+        IL_0025:  add
+        IL_0026:  callvirt   instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_Value(!0)
+        IL_002b:  nop
+        IL_002c:  ldloc.0
+        IL_002d:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0032:  ldloc.1
+        IL_0033:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0038:  add
+        IL_0039:  stloc.2
+        IL_003a:  ldarg.0
+        IL_003b:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f2@5::builder@
+        IL_0040:  stloc.3
+        IL_0041:  ldloc.2
+        IL_0042:  stloc.s    V_4
+        IL_0044:  ldloc.s    V_4
+        IL_0046:  stloc.s    V_5
+        IL_0048:  ldloc.s    V_5
+        IL_004a:  newobj     instance void assembly/assembly/'f2@10-1'::.ctor(int32)
+        IL_004f:  tail.
+        IL_0051:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_0056:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@20-5'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public int32 res
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 res) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 assembly/assembly/'f3@20-5'::res
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      int32 assembly/assembly/'f3@20-5'::res
+        IL_0007:  tail.
+        IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>::Success(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!0>,
+                                                                                                                                                                       !0)
+        IL_000e:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@19-4'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public int32 x1
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> y
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@,
+                                   int32 x1,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> y) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@19-4'::builder@
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      int32 assembly/assembly/'f3@19-4'::x1
+        IL_0014:  ldarg.0
+        IL_0015:  ldarg.3
+        IL_0016:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f3@19-4'::y
+        IL_001b:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(int32 _arg4) cil managed
+      {
+        
+        .maxstack  6
+        .locals init (int32 V_0,
+                 int32 V_1,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_2,
+                 int32 V_3,
+                 int32 V_4)
+        IL_0000:  ldarg.1
+        IL_0001:  stloc.0
+        IL_0002:  ldarg.0
+        IL_0003:  ldfld      int32 assembly/assembly/'f3@19-4'::x1
+        IL_0008:  ldarg.0
+        IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f3@19-4'::y
+        IL_000e:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0013:  add
+        IL_0014:  ldloc.0
+        IL_0015:  add
+        IL_0016:  stloc.1
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@19-4'::builder@
+        IL_001d:  stloc.2
+        IL_001e:  ldloc.1
+        IL_001f:  stloc.3
+        IL_0020:  ldloc.3
+        IL_0021:  stloc.s    V_4
+        IL_0023:  ldloc.s    V_4
+        IL_0025:  newobj     instance void assembly/assembly/'f3@20-5'::.ctor(int32)
+        IL_002a:  tail.
+        IL_002c:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_0031:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@18-6'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> part1
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> part2
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> part1,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> part2) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f3@18-6'::part1
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> assembly/assembly/'f3@18-6'::part2
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f3@18-6'::part1
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> assembly/assembly/'f3@18-6'::part2
+        IL_000d:  tail.
+        IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::Bind<int32,int32>(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!1>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!1,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+        IL_0014:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@16-3'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public int32 x1
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@,
+                                   int32 x1) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@16-3'::builder@
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      int32 assembly/assembly/'f3@16-3'::x1
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(int32 _arg3) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_1,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_2,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_3,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> V_4,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_5,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> V_6)
+        IL_0000:  ldarg.1
+        IL_0001:  stloc.0
+        IL_0002:  ldc.i4.0
+        IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::Ref<int32>(!!0)
+        IL_0008:  stloc.1
+        IL_0009:  ldloc.1
+        IL_000a:  ldloc.1
+        IL_000b:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0010:  ldc.i4.1
+        IL_0011:  add
+        IL_0012:  callvirt   instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_Value(!0)
+        IL_0017:  nop
+        IL_0018:  ldarg.0
+        IL_0019:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@16-3'::builder@
+        IL_001e:  stloc.2
+        IL_001f:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly::f2()
+        IL_0024:  stloc.3
+        IL_0025:  ldarg.0
+        IL_0026:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@16-3'::builder@
+        IL_002b:  ldarg.0
+        IL_002c:  ldfld      int32 assembly/assembly/'f3@16-3'::x1
+        IL_0031:  ldloc.1
+        IL_0032:  newobj     instance void assembly/assembly/'f3@19-4'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder,
+                                                                                                                      int32,
+                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>)
+        IL_0037:  stloc.s    V_4
+        IL_0039:  ldloc.3
+        IL_003a:  stloc.s    V_5
+        IL_003c:  ldloc.s    V_4
+        IL_003e:  stloc.s    V_6
+        IL_0040:  ldloc.s    V_5
+        IL_0042:  ldloc.s    V_6
+        IL_0044:  newobj     instance void assembly/assembly/'f3@18-6'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>,
+                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>)
+        IL_0049:  tail.
+        IL_004b:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_0050:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@15-7'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> part1
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> part2
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> part1,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> part2) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f3@15-7'::part1
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> assembly/assembly/'f3@15-7'::part2
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f3@15-7'::part1
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> assembly/assembly/'f3@15-7'::part2
+        IL_000d:  tail.
+        IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::Bind<int32,int32>(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!1>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!1,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+        IL_0014:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@15-2'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public int32 x1
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@,
+                                   int32 x1) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@15-2'::builder@
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      int32 assembly/assembly/'f3@15-2'::x1
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(int32 _arg2) cil managed
+      {
+        
+        .maxstack  6
+        .locals init (int32 V_0,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_1,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_2,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> V_3,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_4,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> V_5)
+        IL_0000:  ldarg.1
+        IL_0001:  stloc.0
+        IL_0002:  ldarg.0
+        IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@15-2'::builder@
+        IL_0008:  stloc.1
+        IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly::f2()
+        IL_000e:  stloc.2
+        IL_000f:  ldarg.0
+        IL_0010:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@15-2'::builder@
+        IL_0015:  ldarg.0
+        IL_0016:  ldfld      int32 assembly/assembly/'f3@15-2'::x1
+        IL_001b:  newobj     instance void assembly/assembly/'f3@16-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder,
+                                                                                                                      int32)
+        IL_0020:  stloc.3
+        IL_0021:  ldloc.2
+        IL_0022:  stloc.s    V_4
+        IL_0024:  ldloc.3
+        IL_0025:  stloc.s    V_5
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  ldloc.s    V_5
+        IL_002b:  newobj     instance void assembly/assembly/'f3@15-7'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>,
+                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>)
+        IL_0030:  tail.
+        IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_0037:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@14-8'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> part1
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> part2
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> part1,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> part2) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f3@14-8'::part1
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> assembly/assembly/'f3@14-8'::part2
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f3@14-8'::part1
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> assembly/assembly/'f3@14-8'::part2
+        IL_000d:  tail.
+        IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::Bind<int32,int32>(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!1>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!1,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+        IL_0014:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@14-1'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@14-1'::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(int32 _arg1) cil managed
+      {
+        
+        .maxstack  6
+        .locals init (int32 V_0,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_1,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_2,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> V_3,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_4,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> V_5)
+        IL_0000:  ldarg.1
+        IL_0001:  stloc.0
+        IL_0002:  ldarg.0
+        IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@14-1'::builder@
+        IL_0008:  stloc.1
+        IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly::f2()
+        IL_000e:  stloc.2
+        IL_000f:  ldarg.0
+        IL_0010:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@14-1'::builder@
+        IL_0015:  ldloc.0
+        IL_0016:  newobj     instance void assembly/assembly/'f3@15-2'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder,
+                                                                                                                      int32)
+        IL_001b:  stloc.3
+        IL_001c:  ldloc.2
+        IL_001d:  stloc.s    V_4
+        IL_001f:  ldloc.3
+        IL_0020:  stloc.s    V_5
+        IL_0022:  ldloc.s    V_4
+        IL_0024:  ldloc.s    V_5
+        IL_0026:  newobj     instance void assembly/assembly/'f3@14-8'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>,
+                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>)
+        IL_002b:  tail.
+        IL_002d:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_0032:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@13-9'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> part1
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> part2
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> part1,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> part2) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f3@13-9'::part1
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> assembly/assembly/'f3@13-9'::part2
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f3@13-9'::part1
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> assembly/assembly/'f3@13-9'::part2
+        IL_000d:  tail.
+        IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::Bind<int32,int32>(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!1>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!1,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+        IL_0014:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit f3@13
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f3@13::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  6
+        .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_0,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_1,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> V_2,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_3,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f3@13::builder@
+        IL_0006:  stloc.0
+        IL_0007:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly::f2()
+        IL_000c:  stloc.1
+        IL_000d:  ldarg.0
+        IL_000e:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f3@13::builder@
+        IL_0013:  newobj     instance void assembly/assembly/'f3@14-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+        IL_0018:  stloc.2
+        IL_0019:  ldloc.1
+        IL_001a:  stloc.3
+        IL_001b:  ldloc.2
+        IL_001c:  stloc.s    V_4
+        IL_001e:  ldloc.3
+        IL_001f:  ldloc.s    V_4
+        IL_0021:  newobj     instance void assembly/assembly/'f3@13-9'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>,
+                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>)
+        IL_0026:  tail.
+        IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_002d:  ret
+      } 
+
+    } 
+
+    .method public static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> f2() cil managed
+    {
+      
+      .maxstack  4
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_0)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  newobj     instance void assembly/assembly/f2@5::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+      IL_000d:  tail.
+      IL_000f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+      IL_0014:  ret
+    } 
+
+    .method public static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> f3() cil managed
+    {
+      
+      .maxstack  4
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_0)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  newobj     instance void assembly/assembly/f3@13::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+      IL_000d:  tail.
+      IL_000f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+      IL_0014:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_1)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly::f3()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  stloc.1
+      IL_0008:  ldloc.1
+      IL_0009:  ldnull
+      IL_000a:  ldnull
+      IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync::RunSynchronously<int32>(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<int32>,
+                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<valuetype [runtime]System.Threading.CancellationToken>)
+      IL_0010:  pop
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest6.fs.RealInternalSignatureOn.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest6.fs.RealInternalSignatureOn.il.release.bsl
new file mode 100644
index 00000000000..4daf09ef651
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AsyncExpressionStepping/AsyncExpressionSteppingTest6.fs.RealInternalSignatureOn.il.release.bsl
@@ -0,0 +1,788 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public assembly
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f2@10-1'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public int32 'value'
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 'value') cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 assembly/assembly/'f2@10-1'::'value'
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      int32 assembly/assembly/'f2@10-1'::'value'
+        IL_0007:  tail.
+        IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>::Success(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!0>,
+                                                                                                                                                                       !0)
+        IL_000e:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit f2@5
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f2@5::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_0,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_1,
+                 int32 V_2,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_3,
+                 int32 V_4)
+        IL_0000:  ldc.i4.0
+        IL_0001:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::Ref<int32>(!!0)
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_000e:  ldc.i4.1
+        IL_000f:  add
+        IL_0010:  callvirt   instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_Value(!0)
+        IL_0015:  nop
+        IL_0016:  ldc.i4.0
+        IL_0017:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::Ref<int32>(!!0)
+        IL_001c:  stloc.1
+        IL_001d:  ldloc.1
+        IL_001e:  ldloc.1
+        IL_001f:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0024:  ldc.i4.1
+        IL_0025:  add
+        IL_0026:  callvirt   instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_Value(!0)
+        IL_002b:  nop
+        IL_002c:  ldloc.0
+        IL_002d:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0032:  ldloc.1
+        IL_0033:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0038:  add
+        IL_0039:  stloc.2
+        IL_003a:  ldarg.0
+        IL_003b:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f2@5::builder@
+        IL_0040:  stloc.3
+        IL_0041:  ldloc.2
+        IL_0042:  stloc.s    V_4
+        IL_0044:  ldloc.s    V_4
+        IL_0046:  newobj     instance void assembly/assembly/'f2@10-1'::.ctor(int32)
+        IL_004b:  tail.
+        IL_004d:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_0052:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@20-5'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public int32 'value'
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 'value') cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 assembly/assembly/'f3@20-5'::'value'
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      int32 assembly/assembly/'f3@20-5'::'value'
+        IL_0007:  tail.
+        IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>::Success(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!0>,
+                                                                                                                                                                       !0)
+        IL_000e:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@19-4'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public int32 x1
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> y
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@,
+                                   int32 x1,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> y) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@19-4'::builder@
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      int32 assembly/assembly/'f3@19-4'::x1
+        IL_0014:  ldarg.0
+        IL_0015:  ldarg.3
+        IL_0016:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f3@19-4'::y
+        IL_001b:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(int32 _arg4) cil managed
+      {
+        
+        .maxstack  6
+        .locals init (int32 V_0,
+                 int32 V_1,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_2,
+                 int32 V_3)
+        IL_0000:  ldarg.1
+        IL_0001:  stloc.0
+        IL_0002:  ldarg.0
+        IL_0003:  ldfld      int32 assembly/assembly/'f3@19-4'::x1
+        IL_0008:  ldarg.0
+        IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> assembly/assembly/'f3@19-4'::y
+        IL_000e:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0013:  add
+        IL_0014:  ldloc.0
+        IL_0015:  add
+        IL_0016:  stloc.1
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@19-4'::builder@
+        IL_001d:  stloc.2
+        IL_001e:  ldloc.1
+        IL_001f:  stloc.3
+        IL_0020:  ldloc.3
+        IL_0021:  newobj     instance void assembly/assembly/'f3@20-5'::.ctor(int32)
+        IL_0026:  tail.
+        IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_002d:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@18-6'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> computation
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> binder
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> computation,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> binder) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f3@18-6'::computation
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> assembly/assembly/'f3@18-6'::binder
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f3@18-6'::computation
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> assembly/assembly/'f3@18-6'::binder
+        IL_000d:  tail.
+        IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::Bind<int32,int32>(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!1>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!1,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+        IL_0014:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@16-3'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public int32 x1
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@,
+                                   int32 x1) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@16-3'::builder@
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      int32 assembly/assembly/'f3@16-3'::x1
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(int32 _arg3) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_1,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_2,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_3,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> V_4)
+        IL_0000:  ldarg.1
+        IL_0001:  stloc.0
+        IL_0002:  ldc.i4.0
+        IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::Ref<int32>(!!0)
+        IL_0008:  stloc.1
+        IL_0009:  ldloc.1
+        IL_000a:  ldloc.1
+        IL_000b:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_Value()
+        IL_0010:  ldc.i4.1
+        IL_0011:  add
+        IL_0012:  callvirt   instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_Value(!0)
+        IL_0017:  nop
+        IL_0018:  ldarg.0
+        IL_0019:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@16-3'::builder@
+        IL_001e:  stloc.2
+        IL_001f:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly::f2()
+        IL_0024:  stloc.3
+        IL_0025:  ldarg.0
+        IL_0026:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@16-3'::builder@
+        IL_002b:  ldarg.0
+        IL_002c:  ldfld      int32 assembly/assembly/'f3@16-3'::x1
+        IL_0031:  ldloc.1
+        IL_0032:  newobj     instance void assembly/assembly/'f3@19-4'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder,
+                                                                                                                      int32,
+                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>)
+        IL_0037:  stloc.s    V_4
+        IL_0039:  ldloc.3
+        IL_003a:  ldloc.s    V_4
+        IL_003c:  newobj     instance void assembly/assembly/'f3@18-6'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>,
+                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>)
+        IL_0041:  tail.
+        IL_0043:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_0048:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@15-7'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> computation
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> binder
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> computation,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> binder) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f3@15-7'::computation
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> assembly/assembly/'f3@15-7'::binder
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f3@15-7'::computation
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> assembly/assembly/'f3@15-7'::binder
+        IL_000d:  tail.
+        IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::Bind<int32,int32>(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!1>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!1,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+        IL_0014:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@15-2'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public int32 x1
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@,
+                                   int32 x1) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@15-2'::builder@
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      int32 assembly/assembly/'f3@15-2'::x1
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(int32 _arg2) cil managed
+      {
+        
+        .maxstack  6
+        .locals init (int32 V_0,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_1,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_2,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> V_3)
+        IL_0000:  ldarg.1
+        IL_0001:  stloc.0
+        IL_0002:  ldarg.0
+        IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@15-2'::builder@
+        IL_0008:  stloc.1
+        IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly::f2()
+        IL_000e:  stloc.2
+        IL_000f:  ldarg.0
+        IL_0010:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@15-2'::builder@
+        IL_0015:  ldarg.0
+        IL_0016:  ldfld      int32 assembly/assembly/'f3@15-2'::x1
+        IL_001b:  newobj     instance void assembly/assembly/'f3@16-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder,
+                                                                                                                      int32)
+        IL_0020:  stloc.3
+        IL_0021:  ldloc.2
+        IL_0022:  ldloc.3
+        IL_0023:  newobj     instance void assembly/assembly/'f3@15-7'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>,
+                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>)
+        IL_0028:  tail.
+        IL_002a:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_002f:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@14-8'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> computation
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> binder
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> computation,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> binder) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f3@14-8'::computation
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> assembly/assembly/'f3@14-8'::binder
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f3@14-8'::computation
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> assembly/assembly/'f3@14-8'::binder
+        IL_000d:  tail.
+        IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::Bind<int32,int32>(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!1>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!1,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+        IL_0014:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@14-1'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@14-1'::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(int32 _arg1) cil managed
+      {
+        
+        .maxstack  6
+        .locals init (int32 V_0,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_1,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_2,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> V_3)
+        IL_0000:  ldarg.1
+        IL_0001:  stloc.0
+        IL_0002:  ldarg.0
+        IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@14-1'::builder@
+        IL_0008:  stloc.1
+        IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly::f2()
+        IL_000e:  stloc.2
+        IL_000f:  ldarg.0
+        IL_0010:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/'f3@14-1'::builder@
+        IL_0015:  ldloc.0
+        IL_0016:  newobj     instance void assembly/assembly/'f3@15-2'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder,
+                                                                                                                      int32)
+        IL_001b:  stloc.3
+        IL_001c:  ldloc.2
+        IL_001d:  ldloc.3
+        IL_001e:  newobj     instance void assembly/assembly/'f3@14-8'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>,
+                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>)
+        IL_0023:  tail.
+        IL_0025:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_002a:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'f3@13-9'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> computation
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> binder
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> computation,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> binder) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f3@13-9'::computation
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> assembly/assembly/'f3@13-9'::binder
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<int32> ctxt) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  ldarg.0
+        IL_0002:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly/'f3@13-9'::computation
+        IL_0007:  ldarg.0
+        IL_0008:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> assembly/assembly/'f3@13-9'::binder
+        IL_000d:  tail.
+        IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::Bind<int32,int32>(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!1>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!1,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+        IL_0014:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit f3@13
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>
+    {
+      .field public class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder builder@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f3@13::builder@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  6
+        .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_0,
+                 class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_1,
+                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>> V_2)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f3@13::builder@
+        IL_0006:  stloc.0
+        IL_0007:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly::f2()
+        IL_000c:  stloc.1
+        IL_000d:  ldarg.0
+        IL_000e:  ldfld      class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder assembly/assembly/f3@13::builder@
+        IL_0013:  newobj     instance void assembly/assembly/'f3@14-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+        IL_0018:  stloc.2
+        IL_0019:  ldloc.1
+        IL_001a:  ldloc.2
+        IL_001b:  newobj     instance void assembly/assembly/'f3@13-9'::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>,
+                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32>>)
+        IL_0020:  tail.
+        IL_0022:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+        IL_0027:  ret
+      } 
+
+    } 
+
+    .method public static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> f2() cil managed
+    {
+      
+      .maxstack  4
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_0)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  newobj     instance void assembly/assembly/f2@5::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+      IL_000d:  tail.
+      IL_000f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+      IL_0014:  ret
+    } 
+
+    .method public static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> f3() cil managed
+    {
+      
+      .maxstack  4
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder V_0)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  newobj     instance void assembly/assembly/f3@13::.ctor(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder)
+      IL_000d:  tail.
+      IL_000f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+      IL_0014:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> V_1)
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<int32> assembly/assembly::f3()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  stloc.1
+      IL_0008:  ldloc.1
+      IL_0009:  ldnull
+      IL_000a:  ldnull
+      IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync::RunSynchronously<int32>(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<int32>,
+                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<valuetype [runtime]System.Threading.CancellationToken>)
+      IL_0010:  pop
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/AttributeTargets.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/AttributeTargets.fs
index 8b7969e5235..199fb7bda05 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/AttributeTargets.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/AttributeTargets.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open Xunit
 open FSharp.Test
@@ -17,14 +17,38 @@ module AttributeTargets =
         |> verifyBaseline
         |> verifyILBaseline
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Default.fs"|])>]
-    let ``Default_fs`` compilation =
-        verifyCompilation compilation
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Default.fs"|])>]
+    let ``Default_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Field.fs"|])>]
-    let ``Field_fs`` compilation =
-        verifyCompilation compilation
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Default.fs"|])>]
+    let ``Default_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Property.fs"|])>]
-    let ``Property_fs`` compilation =
-        verifyCompilation compilation
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Field.fs"|])>]
+    let ``Field_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Field.fs"|])>]
+    let ``Field_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Property.fs"|])>]
+    let ``Property_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Property.fs"|])>]
+    let ``Property_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Default.fs.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Default.fs.RealInternalSignatureOff.il.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Default.fs.il.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Default.fs.RealInternalSignatureOff.il.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Default.fs.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Default.fs.RealInternalSignatureOff.il.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Default.fs.il.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Default.fs.RealInternalSignatureOff.il.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Default.fs.RealInternalSignatureOn.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Default.fs.RealInternalSignatureOn.il.debug.bsl
new file mode 100644
index 00000000000..fdd3ee27a69
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Default.fs.RealInternalSignatureOn.il.debug.bsl
@@ -0,0 +1,129 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public ExportAttribute
+         extends [runtime]System.Attribute
+  {
+    .custom instance void [runtime]System.AttributeUsageAttribute::.ctor(valuetype [runtime]System.AttributeTargets) = ( 01 00 80 01 00 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Attribute::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .field static assembly int32 T@12
+  .custom instance void M/ExportAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32 get_T() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 M::T@12
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$M::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$M::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ldstr      "hello"
+    IL_0006:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0010:  pop
+    IL_0011:  ldc.i4.1
+    IL_0012:  stsfld     int32 M::T@12
+    IL_0017:  ret
+  } 
+
+  .property int32 T()
+  {
+    .custom instance void M/ExportAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 M::get_T()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void M::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Default.fs.RealInternalSignatureOn.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Default.fs.RealInternalSignatureOn.il.release.bsl
new file mode 100644
index 00000000000..fdd3ee27a69
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Default.fs.RealInternalSignatureOn.il.release.bsl
@@ -0,0 +1,129 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public ExportAttribute
+         extends [runtime]System.Attribute
+  {
+    .custom instance void [runtime]System.AttributeUsageAttribute::.ctor(valuetype [runtime]System.AttributeTargets) = ( 01 00 80 01 00 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Attribute::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .field static assembly int32 T@12
+  .custom instance void M/ExportAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32 get_T() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 M::T@12
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$M::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$M::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ldstr      "hello"
+    IL_0006:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0010:  pop
+    IL_0011:  ldc.i4.1
+    IL_0012:  stsfld     int32 M::T@12
+    IL_0017:  ret
+  } 
+
+  .property int32 T()
+  {
+    .custom instance void M/ExportAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 M::get_T()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void M::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Field.fs.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Field.fs.RealInternalSignatureOff.il.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Field.fs.il.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Field.fs.RealInternalSignatureOff.il.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Field.fs.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Field.fs.RealInternalSignatureOff.il.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Field.fs.il.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Field.fs.RealInternalSignatureOff.il.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Field.fs.RealInternalSignatureOn.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Field.fs.RealInternalSignatureOn.il.debug.bsl
new file mode 100644
index 00000000000..c5544f82a78
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Field.fs.RealInternalSignatureOn.il.debug.bsl
@@ -0,0 +1,128 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public ExportAttribute
+         extends [runtime]System.Attribute
+  {
+    .custom instance void [runtime]System.AttributeUsageAttribute::.ctor(valuetype [runtime]System.AttributeTargets) = ( 01 00 80 01 00 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Attribute::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .field static assembly int32 T@12
+  .custom instance void M/ExportAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32 get_T() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 M::T@12
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$M::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$M::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ldstr      "hello"
+    IL_0006:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0010:  pop
+    IL_0011:  ldc.i4.1
+    IL_0012:  stsfld     int32 M::T@12
+    IL_0017:  ret
+  } 
+
+  .property int32 T()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 M::get_T()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void M::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Field.fs.RealInternalSignatureOn.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Field.fs.RealInternalSignatureOn.il.release.bsl
new file mode 100644
index 00000000000..c5544f82a78
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Field.fs.RealInternalSignatureOn.il.release.bsl
@@ -0,0 +1,128 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public ExportAttribute
+         extends [runtime]System.Attribute
+  {
+    .custom instance void [runtime]System.AttributeUsageAttribute::.ctor(valuetype [runtime]System.AttributeTargets) = ( 01 00 80 01 00 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Attribute::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .field static assembly int32 T@12
+  .custom instance void M/ExportAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32 get_T() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 M::T@12
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$M::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$M::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ldstr      "hello"
+    IL_0006:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0010:  pop
+    IL_0011:  ldc.i4.1
+    IL_0012:  stsfld     int32 M::T@12
+    IL_0017:  ret
+  } 
+
+  .property int32 T()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 M::get_T()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void M::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.RealInternalSignatureOff.il.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.il.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.RealInternalSignatureOff.il.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.RealInternalSignatureOff.il.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.il.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.RealInternalSignatureOff.il.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..1abdfba7578
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,128 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public ExportAttribute
+         extends [runtime]System.Attribute
+  {
+    .custom instance void [runtime]System.AttributeUsageAttribute::.ctor(valuetype [runtime]System.AttributeTargets) = ( 01 00 80 01 00 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Attribute::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .field static assembly int32 T@12
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32 get_T() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 M::T@12
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$M::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$M::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ldstr      "hello"
+    IL_0006:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0010:  pop
+    IL_0011:  ldc.i4.1
+    IL_0012:  stsfld     int32 M::T@12
+    IL_0017:  ret
+  } 
+
+  .property int32 T()
+  {
+    .custom instance void M/ExportAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 M::get_T()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void M::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.RealInternalSignatureOn.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.RealInternalSignatureOn.il.debug.bsl
new file mode 100644
index 00000000000..1abdfba7578
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.RealInternalSignatureOn.il.debug.bsl
@@ -0,0 +1,128 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public ExportAttribute
+         extends [runtime]System.Attribute
+  {
+    .custom instance void [runtime]System.AttributeUsageAttribute::.ctor(valuetype [runtime]System.AttributeTargets) = ( 01 00 80 01 00 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Attribute::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .field static assembly int32 T@12
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32 get_T() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 M::T@12
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$M::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$M::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ldstr      "hello"
+    IL_0006:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0010:  pop
+    IL_0011:  ldc.i4.1
+    IL_0012:  stsfld     int32 M::T@12
+    IL_0017:  ret
+  } 
+
+  .property int32 T()
+  {
+    .custom instance void M/ExportAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 M::get_T()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void M::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.RealInternalSignatureOnil.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.RealInternalSignatureOnil.release.bsl
new file mode 100644
index 00000000000..f4a6cfcd6df
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/AttributeTargets/Property.fs.RealInternalSignatureOnil.release.bsl
@@ -0,0 +1,128 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public ExportAttribute
+         extends [runtime]System.Attribute
+  {
+    .custom instance void [runtime]System.AttributeUsageAttribute::.ctor(valuetype [runtime]System.AttributeTargets) = ( 01 00 80 01 00 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Attribute::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .field static assembly int32 T@12
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32 get_T() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 M::T@12
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$M::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$M::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly static void  staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ldstr      "hello"
+    IL_0006:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0010:  pop
+    IL_0011:  ldc.i4.1
+    IL_0012:  stsfld     int32 M::T@12
+    IL_0017:  ret
+  } 
+
+  .property int32 T()
+  {
+    .custom instance void M/ExportAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 M::get_T()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void M::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ByRefTests.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ByRefTests.fs
index 133e67e45a7..ef8dbac0f0d 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ByRefTests.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ByRefTests.fs
@@ -355,8 +355,7 @@ type IsReadOnlyAttribute() =
 
 type C() =
     let x = 59
-    member _.X: inref<_> = &x
-            """
+    member _.X: inref<_> = &x"""
 
         let verifyProperty = """.property instance int32& modreq([netstandard]System.Runtime.InteropServices.InAttribute)
                 X()
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember.fs
index 1e7b359998a..99c31471aba 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open Xunit
 open FSharp.Test
@@ -17,30 +17,66 @@ module CCtorDUWithMember =
         |> verifyBaseline
         |> verifyILBaseline
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"CCtorDUWithMember01a.fs"|])>]
-    let ``CCtorDUWithMember01a_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"CCtorDUWithMember01a.fs"|])>]
+    let ``CCtorDUWithMember01a_RealInternalSignatureOn_fs`` compilation =
         compilation
         |> asFs
+        |> withRealInternalSignatureOn
         |> withAdditionalSourceFile (SourceFromPath (__SOURCE_DIRECTORY__ ++ "CCtorDUWithMember01.fs"))
         |> verifyCompilation 
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"CCtorDUWithMember02a.fs"|])>]
-    let ``CCtorDUWithMember02a_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"CCtorDUWithMember01a.fs"|])>]
+    let ``CCtorDUWithMember01a_RealInternalSignatureOff_fs`` compilation =
         compilation
         |> asFs
+        |> withRealInternalSignatureOff
+        |> withAdditionalSourceFile (SourceFromPath (__SOURCE_DIRECTORY__ ++ "CCtorDUWithMember01.fs"))
+        |> verifyCompilation 
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"CCtorDUWithMember02a.fs"|])>]
+    let ``CCtorDUWithMember02a_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> asFs
+        |> withAdditionalSourceFile (SourceFromPath (__SOURCE_DIRECTORY__ ++ "CCtorDUWithMember02.fs"))
+        |> verifyCompilation
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"CCtorDUWithMember02a.fs"|])>]
+    let ``CCtorDUWithMember02a_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> asFs
         |> withAdditionalSourceFile (SourceFromPath (__SOURCE_DIRECTORY__ ++ "CCtorDUWithMember02.fs"))
         |> verifyCompilation
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"CCtorDUWithMember03a.fs"|])>]
-    let ``CCtorDUWithMember03a_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"CCtorDUWithMember03a.fs"|])>]
+    let ``CCtorDUWithMember03a_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> asFs
         |> withAdditionalSourceFile (SourceFromPath (__SOURCE_DIRECTORY__ ++ "CCtorDUWithMember03.fs"))
         |> verifyCompilation
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[| "CCtorDUWithMember04a.fs" |])>]
-    let ``CCtorDUWithMember04a_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"CCtorDUWithMember03a.fs"|])>]
+    let ``CCtorDUWithMember03a_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> asFs
+        |> withAdditionalSourceFile (SourceFromPath (__SOURCE_DIRECTORY__ ++ "CCtorDUWithMember03.fs"))
+        |> verifyCompilation
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[| "CCtorDUWithMember04a.fs" |])>]
+    let ``CCtorDUWithMember04a_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> asFs
+        |> withAdditionalSourceFile (SourceFromPath (__SOURCE_DIRECTORY__ ++ "CCtorDUWithMember04.fs"))
+        |> verifyCompilation 
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[| "CCtorDUWithMember04a.fs" |])>]
+    let ``CCtorDUWithMember04a_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> asFs
         |> withAdditionalSourceFile (SourceFromPath (__SOURCE_DIRECTORY__ ++ "CCtorDUWithMember04.fs"))
         |> verifyCompilation 
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember01a.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember01a.fs.RealInternalSignatureOff.il.net472.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember01a.fs.il.net472.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember01a.fs.RealInternalSignatureOff.il.net472.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember01a.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember01a.fs.RealInternalSignatureOff.il.netcore.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember01a.fs.il.netcore.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember01a.fs.RealInternalSignatureOff.il.netcore.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember01a.fs.RealInternalSignatureOn.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember01a.fs.RealInternalSignatureOn.il.net472.bsl
new file mode 100644
index 00000000000..d2af1bde4e8
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember01a.fs.RealInternalSignatureOn.il.net472.bsl
@@ -0,0 +1,618 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed CCtorDUWithMember01
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$CCtorDUWithMember01
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit C
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class assembly/C>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class assembly/C>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                   61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .class abstract auto ansi sealed nested public Tags
+           extends [runtime]System.Object
+    {
+      .field public static literal int32 A = int32(0x00000000)
+      .field public static literal int32 B = int32(0x00000001)
+    } 
+
+    .field assembly initonly int32 _tag
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field static assembly initonly class assembly/C _unique_A
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field static assembly initonly class assembly/C _unique_B
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  newobj     instance void assembly/C::.ctor(int32)
+      IL_0006:  stsfld     class assembly/C assembly/C::_unique_A
+      IL_000b:  ldc.i4.1
+      IL_000c:  newobj     instance void assembly/C::.ctor(int32)
+      IL_0011:  stsfld     class assembly/C assembly/C::_unique_B
+      IL_0016:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 _tag) cil managed
+    {
+      .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                              class [runtime]System.Type) = ( 01 00 E0 07 00 00 16 43 43 74 6F 72 44 55 57 69   
+                                                                                                                               74 68 4D 65 6D 62 65 72 30 31 61 2B 43 00 00 )    
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 assembly/C::_tag
+      IL_000d:  ret
+    } 
+
+    .method public static class assembly/C get_A() cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldsfld     class assembly/C assembly/C::_unique_A
+      IL_0005:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsA() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 assembly/C::get_Tag()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public static class assembly/C get_B() cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldsfld     class assembly/C assembly/C::_unique_B
+      IL_0005:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsB() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 assembly/C::get_Tag()
+      IL_0006:  ldc.i4.1
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/C::_tag
+      IL_0006:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/C,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/C,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/C,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/C,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class assembly/C>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/C,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/C,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class assembly/C obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0020
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001e
+
+      IL_0006:  ldarg.0
+      IL_0007:  ldfld      int32 assembly/C::_tag
+      IL_000c:  stloc.0
+      IL_000d:  ldarg.1
+      IL_000e:  ldfld      int32 assembly/C::_tag
+      IL_0013:  stloc.1
+      IL_0014:  ldloc.0
+      IL_0015:  ldloc.1
+      IL_0016:  bne.un.s   IL_001a
+
+      IL_0018:  ldc.i4.0
+      IL_0019:  ret
+
+      IL_001a:  ldloc.0
+      IL_001b:  ldloc.1
+      IL_001c:  sub
+      IL_001d:  ret
+
+      IL_001e:  ldc.i4.1
+      IL_001f:  ret
+
+      IL_0020:  ldarg.1
+      IL_0021:  brfalse.s  IL_0025
+
+      IL_0023:  ldc.i4.m1
+      IL_0024:  ret
+
+      IL_0025:  ldc.i4.0
+      IL_0026:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  assembly/C
+      IL_0007:  callvirt   instance int32 assembly/C::CompareTo(class assembly/C)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class assembly/C V_0,
+               int32 V_1,
+               int32 V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  assembly/C
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_002c
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  assembly/C
+      IL_0010:  brfalse.s  IL_002a
+
+      IL_0012:  ldarg.0
+      IL_0013:  ldfld      int32 assembly/C::_tag
+      IL_0018:  stloc.1
+      IL_0019:  ldloc.0
+      IL_001a:  ldfld      int32 assembly/C::_tag
+      IL_001f:  stloc.2
+      IL_0020:  ldloc.1
+      IL_0021:  ldloc.2
+      IL_0022:  bne.un.s   IL_0026
+
+      IL_0024:  ldc.i4.0
+      IL_0025:  ret
+
+      IL_0026:  ldloc.1
+      IL_0027:  ldloc.2
+      IL_0028:  sub
+      IL_0029:  ret
+
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldarg.1
+      IL_002d:  unbox.any  assembly/C
+      IL_0032:  brfalse.s  IL_0036
+
+      IL_0034:  ldc.i4.m1
+      IL_0035:  ret
+
+      IL_0036:  ldc.i4.0
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_000c
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  ldfld      int32 assembly/C::_tag
+      IL_000b:  ret
+
+      IL_000c:  ldc.i4.0
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 assembly/C::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class assembly/C V_0,
+               class assembly/C V_1,
+               int32 V_2,
+               int32 V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0024
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     assembly/C
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0022
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  ldfld      int32 assembly/C::_tag
+      IL_0015:  stloc.2
+      IL_0016:  ldloc.1
+      IL_0017:  ldfld      int32 assembly/C::_tag
+      IL_001c:  stloc.3
+      IL_001d:  ldloc.2
+      IL_001e:  ldloc.3
+      IL_001f:  ceq
+      IL_0021:  ret
+
+      IL_0022:  ldc.i4.0
+      IL_0023:  ret
+
+      IL_0024:  ldarg.1
+      IL_0025:  ldnull
+      IL_0026:  cgt.un
+      IL_0028:  ldc.i4.0
+      IL_0029:  ceq
+      IL_002b:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_P() cil managed
+    {
+      
+      .maxstack  3
+      .locals init (class assembly/C V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  stloc.0
+      IL_0002:  ldc.i4.1
+      IL_0003:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class assembly/C obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001b
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_0019
+
+      IL_0006:  ldarg.0
+      IL_0007:  ldfld      int32 assembly/C::_tag
+      IL_000c:  stloc.0
+      IL_000d:  ldarg.1
+      IL_000e:  ldfld      int32 assembly/C::_tag
+      IL_0013:  stloc.1
+      IL_0014:  ldloc.0
+      IL_0015:  ldloc.1
+      IL_0016:  ceq
+      IL_0018:  ret
+
+      IL_0019:  ldc.i4.0
+      IL_001a:  ret
+
+      IL_001b:  ldarg.1
+      IL_001c:  ldnull
+      IL_001d:  cgt.un
+      IL_001f:  ldc.i4.0
+      IL_0020:  ceq
+      IL_0022:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class assembly/C V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     assembly/C
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool assembly/C::Equals(class assembly/C)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 assembly/C::get_Tag()
+    } 
+    .property class assembly/C
+            A()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get class assembly/C assembly/C::get_A()
+    } 
+    .property instance bool IsA()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool assembly/C::get_IsA()
+    } 
+    .property class assembly/C
+            B()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get class assembly/C assembly/C::get_B()
+    } 
+    .property instance bool IsB()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool assembly/C::get_IsB()
+    } 
+    .property instance int32 P()
+    {
+      .get instance int32 assembly/C::get_P()
+    } 
+  } 
+
+  .method public specialname static class assembly/C get_e2() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  call       class assembly/C assembly/C::get_A()
+    IL_0005:  ret
+  } 
+
+  .property class assembly/C e2()
+  {
+    .get class assembly/C assembly::get_e2()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+} 
+
+.class private auto ansi serializable sealed System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+       extends [runtime]System.Enum
+{
+  .custom instance void [runtime]System.FlagsAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field public specialname rtspecialname int32 value__
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes All = int32(0xFFFFFFFF)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes None = int32(0x00000000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicParameterlessConstructor = int32(0x00000001)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicConstructors = int32(0x00000003)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicConstructors = int32(0x00000004)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicMethods = int32(0x00000008)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicMethods = int32(0x00000010)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicFields = int32(0x00000020)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicFields = int32(0x00000040)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicNestedTypes = int32(0x00000080)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicNestedTypes = int32(0x00000100)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicProperties = int32(0x00000200)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicProperties = int32(0x00000400)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicEvents = int32(0x00000800)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicEvents = int32(0x00001000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes Interfaces = int32(0x00002000)
+} 
+
+.class private auto ansi beforefieldinit System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute
+       extends [runtime]System.Attribute
+{
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private class [runtime]System.Type Type@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public specialname rtspecialname 
+          instance void  .ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType,
+                               class [runtime]System.Type Type) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Attribute::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_000d:  ldarg.0
+    IL_000e:  ldarg.2
+    IL_000f:  stfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0014:  ret
+  } 
+
+  .method public hidebysig specialname instance class [runtime]System.Type get_Type() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes get_MemberType() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_0006:  ret
+  } 
+
+  .property instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+          MemberType()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_MemberType()
+  } 
+  .property instance class [runtime]System.Type
+          Type()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_Type()
+  } 
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember01a.fs.RealInternalSignatureOn.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember01a.fs.RealInternalSignatureOn.il.netcore.bsl
new file mode 100644
index 00000000000..e631a36fccb
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember01a.fs.RealInternalSignatureOn.il.netcore.bsl
@@ -0,0 +1,526 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed CCtorDUWithMember01
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$CCtorDUWithMember01
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit C
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class assembly/C>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class assembly/C>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                         61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .class abstract auto ansi sealed nested public Tags
+           extends [runtime]System.Object
+    {
+      .field public static literal int32 A = int32(0x00000000)
+      .field public static literal int32 B = int32(0x00000001)
+    } 
+
+    .field assembly initonly int32 _tag
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field static assembly initonly class assembly/C _unique_A
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field static assembly initonly class assembly/C _unique_B
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  newobj     instance void assembly/C::.ctor(int32)
+      IL_0006:  stsfld     class assembly/C assembly/C::_unique_A
+      IL_000b:  ldc.i4.1
+      IL_000c:  newobj     instance void assembly/C::.ctor(int32)
+      IL_0011:  stsfld     class assembly/C assembly/C::_unique_B
+      IL_0016:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 _tag) cil managed
+    {
+      .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                              class [runtime]System.Type) = ( 01 00 E0 07 00 00 16 43 43 74 6F 72 44 55 57 69   
+                                                                                                                                                     74 68 4D 65 6D 62 65 72 30 31 61 2B 43 00 00 )    
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 assembly/C::_tag
+      IL_000d:  ret
+    } 
+
+    .method public static class assembly/C get_A() cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldsfld     class assembly/C assembly/C::_unique_A
+      IL_0005:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsA() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 assembly/C::get_Tag()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public static class assembly/C get_B() cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldsfld     class assembly/C assembly/C::_unique_B
+      IL_0005:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsB() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 assembly/C::get_Tag()
+      IL_0006:  ldc.i4.1
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/C::_tag
+      IL_0006:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/C,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/C,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/C,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/C,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class assembly/C>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/C,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/C,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class assembly/C obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0020
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001e
+
+      IL_0006:  ldarg.0
+      IL_0007:  ldfld      int32 assembly/C::_tag
+      IL_000c:  stloc.0
+      IL_000d:  ldarg.1
+      IL_000e:  ldfld      int32 assembly/C::_tag
+      IL_0013:  stloc.1
+      IL_0014:  ldloc.0
+      IL_0015:  ldloc.1
+      IL_0016:  bne.un.s   IL_001a
+
+      IL_0018:  ldc.i4.0
+      IL_0019:  ret
+
+      IL_001a:  ldloc.0
+      IL_001b:  ldloc.1
+      IL_001c:  sub
+      IL_001d:  ret
+
+      IL_001e:  ldc.i4.1
+      IL_001f:  ret
+
+      IL_0020:  ldarg.1
+      IL_0021:  brfalse.s  IL_0025
+
+      IL_0023:  ldc.i4.m1
+      IL_0024:  ret
+
+      IL_0025:  ldc.i4.0
+      IL_0026:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  assembly/C
+      IL_0007:  callvirt   instance int32 assembly/C::CompareTo(class assembly/C)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class assembly/C V_0,
+               int32 V_1,
+               int32 V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  assembly/C
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_002c
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  assembly/C
+      IL_0010:  brfalse.s  IL_002a
+
+      IL_0012:  ldarg.0
+      IL_0013:  ldfld      int32 assembly/C::_tag
+      IL_0018:  stloc.1
+      IL_0019:  ldloc.0
+      IL_001a:  ldfld      int32 assembly/C::_tag
+      IL_001f:  stloc.2
+      IL_0020:  ldloc.1
+      IL_0021:  ldloc.2
+      IL_0022:  bne.un.s   IL_0026
+
+      IL_0024:  ldc.i4.0
+      IL_0025:  ret
+
+      IL_0026:  ldloc.1
+      IL_0027:  ldloc.2
+      IL_0028:  sub
+      IL_0029:  ret
+
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldarg.1
+      IL_002d:  unbox.any  assembly/C
+      IL_0032:  brfalse.s  IL_0036
+
+      IL_0034:  ldc.i4.m1
+      IL_0035:  ret
+
+      IL_0036:  ldc.i4.0
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_000c
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  ldfld      int32 assembly/C::_tag
+      IL_000b:  ret
+
+      IL_000c:  ldc.i4.0
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 assembly/C::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class assembly/C V_0,
+               class assembly/C V_1,
+               int32 V_2,
+               int32 V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0024
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     assembly/C
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0022
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  ldfld      int32 assembly/C::_tag
+      IL_0015:  stloc.2
+      IL_0016:  ldloc.1
+      IL_0017:  ldfld      int32 assembly/C::_tag
+      IL_001c:  stloc.3
+      IL_001d:  ldloc.2
+      IL_001e:  ldloc.3
+      IL_001f:  ceq
+      IL_0021:  ret
+
+      IL_0022:  ldc.i4.0
+      IL_0023:  ret
+
+      IL_0024:  ldarg.1
+      IL_0025:  ldnull
+      IL_0026:  cgt.un
+      IL_0028:  ldc.i4.0
+      IL_0029:  ceq
+      IL_002b:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_P() cil managed
+    {
+      
+      .maxstack  3
+      .locals init (class assembly/C V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  stloc.0
+      IL_0002:  ldc.i4.1
+      IL_0003:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class assembly/C obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001b
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_0019
+
+      IL_0006:  ldarg.0
+      IL_0007:  ldfld      int32 assembly/C::_tag
+      IL_000c:  stloc.0
+      IL_000d:  ldarg.1
+      IL_000e:  ldfld      int32 assembly/C::_tag
+      IL_0013:  stloc.1
+      IL_0014:  ldloc.0
+      IL_0015:  ldloc.1
+      IL_0016:  ceq
+      IL_0018:  ret
+
+      IL_0019:  ldc.i4.0
+      IL_001a:  ret
+
+      IL_001b:  ldarg.1
+      IL_001c:  ldnull
+      IL_001d:  cgt.un
+      IL_001f:  ldc.i4.0
+      IL_0020:  ceq
+      IL_0022:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class assembly/C V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     assembly/C
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool assembly/C::Equals(class assembly/C)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 assembly/C::get_Tag()
+    } 
+    .property class assembly/C
+            A()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get class assembly/C assembly/C::get_A()
+    } 
+    .property instance bool IsA()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool assembly/C::get_IsA()
+    } 
+    .property class assembly/C
+            B()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get class assembly/C assembly/C::get_B()
+    } 
+    .property instance bool IsB()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool assembly/C::get_IsB()
+    } 
+    .property instance int32 P()
+    {
+      .get instance int32 assembly/C::get_P()
+    } 
+  } 
+
+  .method public specialname static class assembly/C get_e2() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  call       class assembly/C assembly/C::get_A()
+    IL_0005:  ret
+  } 
+
+  .property class assembly/C e2()
+  {
+    .get class assembly/C assembly::get_e2()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember02a.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember02a.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember02a.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember02a.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember02a.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember02a.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..2c5467b662b
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember02a.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,189 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed CCtorDUWithMember02
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$CCtorDUWithMember02
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public M
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .field static assembly int32 x@7
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .method public specialname static int32 get_x() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldsfld     int32 assembly/M::x@7
+      IL_0005:  ret
+    } 
+
+    .method public specialname static void set_x(int32 'value') cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  stsfld     int32 assembly/M::x@7
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello2"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_000f:  pop
+      IL_0010:  ldstr      "1"
+      IL_0015:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_001a:  stsfld     int32 assembly/M::x@7
+      IL_001f:  ret
+    } 
+
+    .property int32 x()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+      .set void assembly/M::set_x(int32)
+      .get int32 assembly/M::get_x()
+    } 
+  } 
+
+  .field static assembly int32 y@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32 get_y() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::y@9
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello1"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_000f:  pop
+    IL_0010:  call       void assembly/M::staticInitialization@()
+    IL_0015:  nop
+    IL_0016:  ldstr      "hello3"
+    IL_001b:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_0020:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0025:  pop
+    IL_0026:  call       int32 assembly/M::get_x()
+    IL_002b:  stsfld     int32 assembly::y@9
+    IL_0030:  ret
+  } 
+
+  .property int32 y()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_y()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember03a.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember03a.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember03a.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember03a.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember03a.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember03a.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..978d0e366ea
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember03a.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,133 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed CCtorDUWithMember03
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$CCtorDUWithMember03
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly int32 x@3
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32 get_x() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::x@3
+    IL_0005:  ret
+  } 
+
+  .method public specialname static void set_x(int32 'value') cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  stsfld     int32 assembly::x@3
+    IL_0006:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.1
+    IL_0001:  stsfld     int32 assembly::x@3
+    IL_0006:  ret
+  } 
+
+  .property int32 x()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .set void assembly::set_x(int32)
+    .get int32 assembly::get_x()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember04a.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember04a.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember04a.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember04a.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember04a.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember04a.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..315a9ab425d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CCtorDUWithMember/CCtorDUWithMember04a.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,119 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Program
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldstr      "File1.x = %A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_000f:  call       int32 assembly::get_x()
+    IL_0014:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0019:  pop
+    IL_001a:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Program
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Program::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public specialname static int32 get_x() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.1
+    IL_0001:  ret
+  } 
+
+  .property int32 x()
+  {
+    .get int32 assembly::get_x()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute.fs
index 27aca6b92b4..7821dd195d0 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open Xunit
 open FSharp.Test
@@ -33,9 +33,16 @@ module CompiledNameAttribute =
         compilation
         |> verifyCompilation
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"CompiledNameAttribute04.fs"|])>]
-    let ``CompiledNameAttribute04_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"CompiledNameAttribute04_RealInternalSignatureOn.fs"|])>]
+    let ``CompiledNameAttribute04_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation 
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"CompiledNameAttribute04_RealInternalSignatureOff.fs"|])>]
+    let ``CompiledNameAttribute04_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation 
 
     [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"CompiledNameAttribute05.fs"|])>]
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOff.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOff.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOff.fs.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOff.fs.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOff.fs.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOff.fs.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOff.fs.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOff.fs.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOff.fs.il.netcore.release.bsl
similarity index 97%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOff.fs.il.netcore.release.bsl
index 5ad043e0603..e266b844053 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04.fs.il.netcore.release.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOff.fs.il.netcore.release.bsl
@@ -1,388 +1,388 @@
-
-
-
-
-
-.assembly extern runtime { }
-.assembly extern FSharp.Core { }
-.assembly extern runtime { }
-.assembly assembly
-{
-  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
-                                                                                                      int32,
-                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
-
-  
-  
-
-  .hash algorithm 0x00008004
-  .ver 0:0:0:0
-}
-.mresource public FSharpSignatureData.assembly
-{
-  
-  
-}
-.mresource public FSharpOptimizationData.assembly
-{
-  
-  
-}
-.module assembly.exe
-
-.imagebase {value}
-.file alignment 0x00000200
-.stackreserve 0x00100000
-.subsystem 0x0003       
-.corflags 0x00000001    
-
-
-
-
-
-.class public abstract auto ansi sealed Program
-       extends [runtime]System.Object
-{
-  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
-  .class abstract auto ansi serializable nested public C
-         extends [runtime]System.Object
-  {
-    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.AbstractClassAttribute::.ctor() = ( 01 00 00 00 ) 
-    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
-    .method public hidebysig abstract virtual 
-            instance int32  A1(int32 A_1,
-                               int32 A_2) cil managed
-    {
-      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
-    } 
-
-    .method public hidebysig abstract virtual 
-            instance int32  A2(int32 A_1) cil managed
-    {
-    } 
-
-    .method public specialname rtspecialname 
-            instance void  .ctor() cil managed
-    {
-      
-      .maxstack  8
-      IL_0000:  ldarg.0
-      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
-      IL_0006:  ldarg.0
-      IL_0007:  pop
-      IL_0008:  ret
-    } 
-
-    .method public hidebysig specialname 
-            instance int32  get_P() cil managed
-    {
-      
-      .maxstack  8
-      IL_0000:  ldc.i4.1
-      IL_0001:  ret
-    } 
-
-    .method public hidebysig instance int32 
-            M1(int32 x,
-               int32 y) cil managed
-    {
-      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
-      
-      .maxstack  8
-      IL_0000:  ldarg.1
-      IL_0001:  ldarg.2
-      IL_0002:  add
-      IL_0003:  ret
-    } 
-
-    .method public hidebysig instance !!a 
-            M2<a>(!!a x) cil managed preservesig
-    {
-      
-      .maxstack  8
-      IL_0000:  ldarg.1
-      IL_0001:  ret
-    } 
-
-    .property instance int32 P()
-    {
-      .get instance int32 Program/C::get_P()
-    } 
-  } 
-
-  .class interface abstract auto ansi serializable nested public IInterface
-  {
-    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
-    .method public hidebysig abstract virtual 
-            instance int32  SomeMethod(int32 A_1) cil managed preservesig
-    {
-    } 
-
-  } 
-
-  .class sequential ansi serializable sealed nested public S
-         extends [runtime]System.ValueType
-         implements class [runtime]System.IEquatable`1<valuetype Program/S>,
-                    [runtime]System.Collections.IStructuralEquatable,
-                    class [runtime]System.IComparable`1<valuetype Program/S>,
-                    [runtime]System.IComparable,
-                    [runtime]System.Collections.IStructuralComparable
-  {
-    .pack 0
-    .size 1
-    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(valuetype Program/S obj) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  3
-      .locals init (valuetype Program/S& V_0)
-      IL_0000:  ldarga.s   obj
-      IL_0002:  stloc.0
-      IL_0003:  ldc.i4.0
-      IL_0004:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(object obj) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  8
-      IL_0000:  ldarg.0
-      IL_0001:  ldarg.1
-      IL_0002:  unbox.any  Program/S
-      IL_0007:  call       instance int32 Program/S::CompareTo(valuetype Program/S)
-      IL_000c:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(object obj,
-                                      class [runtime]System.Collections.IComparer comp) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  3
-      .locals init (valuetype Program/S V_0,
-               valuetype Program/S& V_1)
-      IL_0000:  ldarg.1
-      IL_0001:  unbox.any  Program/S
-      IL_0006:  stloc.0
-      IL_0007:  ldloca.s   V_0
-      IL_0009:  stloc.1
-      IL_000a:  ldc.i4.0
-      IL_000b:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  8
-      IL_0000:  ldc.i4.0
-      IL_0001:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode() cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  8
-      IL_0000:  ldarg.0
-      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
-      IL_0006:  call       instance int32 Program/S::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
-      IL_000b:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance bool  Equals(object obj,
-                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  3
-      .locals init (object V_0,
-               valuetype Program/S V_1,
-               valuetype Program/S& V_2)
-      IL_0000:  ldarg.1
-      IL_0001:  stloc.0
-      IL_0002:  ldloc.0
-      IL_0003:  isinst     Program/S
-      IL_0008:  ldnull
-      IL_0009:  cgt.un
-      IL_000b:  brfalse.s  IL_0019
-
-      IL_000d:  ldarg.1
-      IL_000e:  unbox.any  Program/S
-      IL_0013:  stloc.1
-      IL_0014:  ldloca.s   V_1
-      IL_0016:  stloc.2
-      IL_0017:  ldc.i4.1
-      IL_0018:  ret
-
-      IL_0019:  ldc.i4.0
-      IL_001a:  ret
-    } 
-
-    .method public hidebysig instance !!a 
-            M1<a>(!!a x) cil managed preservesig
-    {
-      
-      .maxstack  8
-      IL_0000:  ldarg.1
-      IL_0001:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance bool  Equals(valuetype Program/S obj) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  3
-      .locals init (valuetype Program/S& V_0)
-      IL_0000:  ldarga.s   obj
-      IL_0002:  stloc.0
-      IL_0003:  ldc.i4.1
-      IL_0004:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance bool  Equals(object obj) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  4
-      .locals init (object V_0,
-               valuetype Program/S V_1)
-      IL_0000:  ldarg.1
-      IL_0001:  stloc.0
-      IL_0002:  ldloc.0
-      IL_0003:  isinst     Program/S
-      IL_0008:  ldnull
-      IL_0009:  cgt.un
-      IL_000b:  brfalse.s  IL_001c
-
-      IL_000d:  ldarg.1
-      IL_000e:  unbox.any  Program/S
-      IL_0013:  stloc.1
-      IL_0014:  ldarg.0
-      IL_0015:  ldloc.1
-      IL_0016:  call       instance bool Program/S::Equals(valuetype Program/S)
-      IL_001b:  ret
-
-      IL_001c:  ldc.i4.0
-      IL_001d:  ret
-    } 
-
-  } 
-
-  .class interface abstract auto ansi serializable nested public ITestInterface
-  {
-    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
-    .method public hidebysig abstract virtual 
-            instance int32  M(int32 A_1) cil managed
-    {
-    } 
-
-  } 
-
-  .class auto autochar serializable sealed nested assembly beforefieldinit specialname a@49
-         extends [runtime]System.Object
-         implements Program/ITestInterface
-  {
-    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
-    .method public specialname rtspecialname 
-            instance void  .ctor() cil managed
-    {
-      
-      .maxstack  8
-      IL_0000:  ldarg.0
-      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
-      IL_0006:  ldarg.0
-      IL_0007:  pop
-      IL_0008:  ret
-    } 
-
-    .method private hidebysig newslot virtual final 
-            instance int32  Program.ITestInterface.M(int32 x) cil managed
-    {
-      .custom instance void [System.Runtime.InteropServices]System.Runtime.InteropServices.PreserveSigAttribute::.ctor() = ( 01 00 00 00 ) 
-      .override Program/ITestInterface::M
-      
-      .maxstack  8
-      IL_0000:  ldarg.1
-      IL_0001:  ldc.i4.1
-      IL_0002:  add
-      IL_0003:  ret
-    } 
-
-  } 
-
-  .method public static int32  f1(int32 x,
-                                  int32 y) cil managed
-  {
-    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
-    
-    .maxstack  8
-    IL_0000:  ldarg.0
-    IL_0001:  ldarg.1
-    IL_0002:  add
-    IL_0003:  ret
-  } 
-
-  .method public static !!a  f2<a>(!!a x) cil managed
-  {
-    
-    .maxstack  8
-    IL_0000:  ldarg.0
-    IL_0001:  ret
-  } 
-
-  .method public specialname static class Program/ITestInterface 
-          get_a() cil managed
-  {
-    
-    .maxstack  8
-    IL_0000:  ldsfld     class Program/ITestInterface '<StartupCode$assembly>'.$Program::a@49
-    IL_0005:  ret
-  } 
-
-  .property class Program/ITestInterface a()
-  {
-    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
-    .get class Program/ITestInterface Program::get_a()
-  } 
-} 
-
-.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Program
-       extends [runtime]System.Object
-{
-  .field static assembly class Program/ITestInterface a@49
-  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-  .field static assembly int32 init@
-  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-  .method public static void  main@() cil managed
-  {
-    .entrypoint
-    
-    .maxstack  4
-    .locals init (class Program/ITestInterface V_0)
-    IL_0000:  newobj     instance void Program/a@49::.ctor()
-    IL_0005:  dup
-    IL_0006:  stsfld     class Program/ITestInterface '<StartupCode$assembly>'.$Program::a@49
-    IL_000b:  stloc.0
-    IL_000c:  ret
-  } 
-
-} 
-
-
-
-
-
-
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern runtime { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Program
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi serializable nested public C
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.AbstractClassAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig abstract virtual 
+            instance int32  A1(int32 A_1,
+                               int32 A_2) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    } 
+
+    .method public hidebysig abstract virtual 
+            instance int32  A2(int32 A_1) cil managed
+    {
+    } 
+
+    .method public specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_P() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.1
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig instance int32 
+            M1(int32 x,
+               int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public hidebysig instance !!a 
+            M2<a>(!!a x) cil managed preservesig
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .property instance int32 P()
+    {
+      .get instance int32 Program/C::get_P()
+    } 
+  } 
+
+  .class interface abstract auto ansi serializable nested public IInterface
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig abstract virtual 
+            instance int32  SomeMethod(int32 A_1) cil managed preservesig
+    {
+    } 
+
+  } 
+
+  .class sequential ansi serializable sealed nested public S
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype Program/S>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype Program/S>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .pack 0
+    .size 1
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(valuetype Program/S obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (valuetype Program/S& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldc.i4.0
+      IL_0004:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  Program/S
+      IL_0007:  call       instance int32 Program/S::CompareTo(valuetype Program/S)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (valuetype Program/S V_0,
+               valuetype Program/S& V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  Program/S
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldc.i4.0
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 Program/S::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (object V_0,
+               valuetype Program/S V_1,
+               valuetype Program/S& V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     Program/S
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_0019
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  Program/S
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldc.i4.1
+      IL_0018:  ret
+
+      IL_0019:  ldc.i4.0
+      IL_001a:  ret
+    } 
+
+    .method public hidebysig instance !!a 
+            M1<a>(!!a x) cil managed preservesig
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(valuetype Program/S obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (valuetype Program/S& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldc.i4.1
+      IL_0004:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype Program/S V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     Program/S
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  Program/S
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool Program/S::Equals(valuetype Program/S)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+  } 
+
+  .class interface abstract auto ansi serializable nested public ITestInterface
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig abstract virtual 
+            instance int32  M(int32 A_1) cil managed
+    {
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname a@49
+         extends [runtime]System.Object
+         implements Program/ITestInterface
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method private hidebysig newslot virtual final 
+            instance int32  Program.ITestInterface.M(int32 x) cil managed
+    {
+      .custom instance void [System.Runtime.InteropServices]System.Runtime.InteropServices.PreserveSigAttribute::.ctor() = ( 01 00 00 00 ) 
+      .override Program/ITestInterface::M
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+  } 
+
+  .method public static int32  f1(int32 x,
+                                  int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public static !!a  f2<a>(!!a x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ret
+  } 
+
+  .method public specialname static class Program/ITestInterface 
+          get_a() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class Program/ITestInterface '<StartupCode$assembly>'.$Program::a@49
+    IL_0005:  ret
+  } 
+
+  .property class Program/ITestInterface a()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class Program/ITestInterface Program::get_a()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Program
+       extends [runtime]System.Object
+{
+  .field static assembly class Program/ITestInterface a@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  4
+    .locals init (class Program/ITestInterface V_0)
+    IL_0000:  newobj     instance void Program/a@49::.ctor()
+    IL_0005:  dup
+    IL_0006:  stsfld     class Program/ITestInterface '<StartupCode$assembly>'.$Program::a@49
+    IL_000b:  stloc.0
+    IL_000c:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOn.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOn.fs
new file mode 100644
index 00000000000..24c007eee73
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOn.fs
@@ -0,0 +1,51 @@
+// #Regression #NoMono #NoMT #CodeGen #EmittedIL #Attributes   
+// Regression test for FSharp1.0:4740
+// Title: Expose currying information in F# compiled form
+
+// Regression test for FSharp1.0:4661
+// Title: PreserveSigAttribute pseudo-custom attribute on COM interop interfaces does not compile correctly
+
+// Regression test for FSharp1.0:5684
+// Title: We should align generation of IL code for pseudo-custom attributes like PreserveSigAttribute for all language constructs (currently, it is incorrect for object expressions)
+module Program
+
+open System
+open System.Runtime.InteropServices
+
+
+let f1 x y = x + y
+let f2 x = x 
+
+[<AbstractClass>]
+type C() = 
+  member this.P = 1
+  member this.M1 x y = x + y 
+  [<PreserveSigAttribute>]
+  member this.M2 x = x 
+
+  abstract A1 : int -> int -> int
+  abstract A2 : int -> int 
+
+
+type IInterface =
+    interface
+        [<PreserveSigAttribute>]
+        abstract SomeMethod : int -> int
+    end
+
+
+type S = 
+  struct
+    [<PreserveSigAttribute>]
+    member this.M1 x = x
+  end
+
+
+type ITestInterface =
+    interface
+        abstract M : int -> int
+    end
+
+let a = { new ITestInterface with
+              [<PreserveSigAttribute>]
+              member this.M x = x + 1 }
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOn.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOn.fs.il.net472.debug.bsl
new file mode 100644
index 00000000000..4f200c9131a
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOn.fs.il.net472.debug.bsl
@@ -0,0 +1,387 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Program
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi serializable nested public C
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.AbstractClassAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig abstract virtual 
+            instance int32  A1(int32 A_1,
+                               int32 A_2) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    } 
+
+    .method public hidebysig abstract virtual instance int32  A2(int32 A_1) cil managed
+    {
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_P() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.1
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig instance int32 
+            M1(int32 x,
+               int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public hidebysig instance !!a M2<a>(!!a x) cil managed preservesig
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .property instance int32 P()
+    {
+      .get instance int32 Program/C::get_P()
+    } 
+  } 
+
+  .class interface abstract auto ansi serializable nested public IInterface
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig abstract virtual instance int32  SomeMethod(int32 A_1) cil managed preservesig
+    {
+    } 
+
+  } 
+
+  .class sequential ansi serializable sealed nested public S
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype Program/S>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype Program/S>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .pack 0
+    .size 1
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig virtual final instance int32  CompareTo(valuetype Program/S obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (valuetype Program/S& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldc.i4.0
+      IL_0004:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  Program/S
+      IL_0007:  call       instance int32 Program/S::CompareTo(valuetype Program/S)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (valuetype Program/S V_0,
+               valuetype Program/S& V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  Program/S
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldc.i4.0
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 Program/S::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (object V_0,
+               valuetype Program/S V_1,
+               valuetype Program/S& V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     Program/S
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_0019
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  Program/S
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldc.i4.1
+      IL_0018:  ret
+
+      IL_0019:  ldc.i4.0
+      IL_001a:  ret
+    } 
+
+    .method public hidebysig instance !!a M1<a>(!!a x) cil managed preservesig
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(valuetype Program/S obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (valuetype Program/S& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldc.i4.1
+      IL_0004:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype Program/S V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     Program/S
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  Program/S
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool Program/S::Equals(valuetype Program/S)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+  } 
+
+  .class interface abstract auto ansi serializable nested public ITestInterface
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig abstract virtual instance int32  M(int32 A_1) cil managed
+    {
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname a@49
+         extends [runtime]System.Object
+         implements Program/ITestInterface
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method private hidebysig newslot virtual final instance int32  Program.ITestInterface.M(int32 x) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.InteropServices.PreserveSigAttribute::.ctor() = ( 01 00 00 00 ) 
+      .override Program/ITestInterface::M
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+  } 
+
+  .field static assembly class Program/ITestInterface a@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public static int32  f1(int32 x,
+                                  int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public static !!a  f2<a>(!!a x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ret
+  } 
+
+  .method public specialname static class Program/ITestInterface get_a() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class Program/ITestInterface Program::a@49
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  newobj     instance void Program/a@49::.ctor()
+    IL_0005:  stsfld     class Program/ITestInterface Program::a@49
+    IL_000a:  ret
+  } 
+
+  .property class Program/ITestInterface a()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class Program/ITestInterface Program::get_a()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Program
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Program::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOn.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOn.fs.il.net472.release.bsl
new file mode 100644
index 00000000000..4f200c9131a
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOn.fs.il.net472.release.bsl
@@ -0,0 +1,387 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Program
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi serializable nested public C
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.AbstractClassAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig abstract virtual 
+            instance int32  A1(int32 A_1,
+                               int32 A_2) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    } 
+
+    .method public hidebysig abstract virtual instance int32  A2(int32 A_1) cil managed
+    {
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_P() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.1
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig instance int32 
+            M1(int32 x,
+               int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public hidebysig instance !!a M2<a>(!!a x) cil managed preservesig
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .property instance int32 P()
+    {
+      .get instance int32 Program/C::get_P()
+    } 
+  } 
+
+  .class interface abstract auto ansi serializable nested public IInterface
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig abstract virtual instance int32  SomeMethod(int32 A_1) cil managed preservesig
+    {
+    } 
+
+  } 
+
+  .class sequential ansi serializable sealed nested public S
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype Program/S>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype Program/S>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .pack 0
+    .size 1
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig virtual final instance int32  CompareTo(valuetype Program/S obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (valuetype Program/S& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldc.i4.0
+      IL_0004:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  Program/S
+      IL_0007:  call       instance int32 Program/S::CompareTo(valuetype Program/S)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (valuetype Program/S V_0,
+               valuetype Program/S& V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  Program/S
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldc.i4.0
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 Program/S::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (object V_0,
+               valuetype Program/S V_1,
+               valuetype Program/S& V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     Program/S
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_0019
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  Program/S
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldc.i4.1
+      IL_0018:  ret
+
+      IL_0019:  ldc.i4.0
+      IL_001a:  ret
+    } 
+
+    .method public hidebysig instance !!a M1<a>(!!a x) cil managed preservesig
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(valuetype Program/S obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (valuetype Program/S& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldc.i4.1
+      IL_0004:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype Program/S V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     Program/S
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  Program/S
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool Program/S::Equals(valuetype Program/S)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+  } 
+
+  .class interface abstract auto ansi serializable nested public ITestInterface
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig abstract virtual instance int32  M(int32 A_1) cil managed
+    {
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname a@49
+         extends [runtime]System.Object
+         implements Program/ITestInterface
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method private hidebysig newslot virtual final instance int32  Program.ITestInterface.M(int32 x) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.InteropServices.PreserveSigAttribute::.ctor() = ( 01 00 00 00 ) 
+      .override Program/ITestInterface::M
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+  } 
+
+  .field static assembly class Program/ITestInterface a@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public static int32  f1(int32 x,
+                                  int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public static !!a  f2<a>(!!a x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ret
+  } 
+
+  .method public specialname static class Program/ITestInterface get_a() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class Program/ITestInterface Program::a@49
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  newobj     instance void Program/a@49::.ctor()
+    IL_0005:  stsfld     class Program/ITestInterface Program::a@49
+    IL_000a:  ret
+  } 
+
+  .property class Program/ITestInterface a()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class Program/ITestInterface Program::get_a()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Program
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Program::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOn.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOn.fs.il.netcore.debug.bsl
new file mode 100644
index 00000000000..23bd08a2e1a
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOn.fs.il.netcore.debug.bsl
@@ -0,0 +1,388 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern runtime { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Program
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi serializable nested public C
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.AbstractClassAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig abstract virtual 
+            instance int32  A1(int32 A_1,
+                               int32 A_2) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    } 
+
+    .method public hidebysig abstract virtual instance int32  A2(int32 A_1) cil managed
+    {
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_P() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.1
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig instance int32 
+            M1(int32 x,
+               int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public hidebysig instance !!a M2<a>(!!a x) cil managed preservesig
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .property instance int32 P()
+    {
+      .get instance int32 Program/C::get_P()
+    } 
+  } 
+
+  .class interface abstract auto ansi serializable nested public IInterface
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig abstract virtual instance int32  SomeMethod(int32 A_1) cil managed preservesig
+    {
+    } 
+
+  } 
+
+  .class sequential ansi serializable sealed nested public S
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype Program/S>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype Program/S>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .pack 0
+    .size 1
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig virtual final instance int32  CompareTo(valuetype Program/S obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (valuetype Program/S& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldc.i4.0
+      IL_0004:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  Program/S
+      IL_0007:  call       instance int32 Program/S::CompareTo(valuetype Program/S)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (valuetype Program/S V_0,
+               valuetype Program/S& V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  Program/S
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldc.i4.0
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 Program/S::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (object V_0,
+               valuetype Program/S V_1,
+               valuetype Program/S& V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     Program/S
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_0019
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  Program/S
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldc.i4.1
+      IL_0018:  ret
+
+      IL_0019:  ldc.i4.0
+      IL_001a:  ret
+    } 
+
+    .method public hidebysig instance !!a M1<a>(!!a x) cil managed preservesig
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(valuetype Program/S obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (valuetype Program/S& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldc.i4.1
+      IL_0004:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype Program/S V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     Program/S
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  Program/S
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool Program/S::Equals(valuetype Program/S)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+  } 
+
+  .class interface abstract auto ansi serializable nested public ITestInterface
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig abstract virtual instance int32  M(int32 A_1) cil managed
+    {
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname a@49
+         extends [runtime]System.Object
+         implements Program/ITestInterface
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method private hidebysig newslot virtual final instance int32  Program.ITestInterface.M(int32 x) cil managed
+    {
+      .custom instance void [System.Runtime.InteropServices]System.Runtime.InteropServices.PreserveSigAttribute::.ctor() = ( 01 00 00 00 ) 
+      .override Program/ITestInterface::M
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+  } 
+
+  .field static assembly class Program/ITestInterface a@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public static int32  f1(int32 x,
+                                  int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public static !!a  f2<a>(!!a x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ret
+  } 
+
+  .method public specialname static class Program/ITestInterface get_a() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class Program/ITestInterface Program::a@49
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  newobj     instance void Program/a@49::.ctor()
+    IL_0005:  stsfld     class Program/ITestInterface Program::a@49
+    IL_000a:  ret
+  } 
+
+  .property class Program/ITestInterface a()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class Program/ITestInterface Program::get_a()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Program
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Program::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOn.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOn.fs.il.netcore.release.bsl
new file mode 100644
index 00000000000..23bd08a2e1a
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompiledNameAttribute/CompiledNameAttribute04_RealInternalSignatureOn.fs.il.netcore.release.bsl
@@ -0,0 +1,388 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern runtime { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Program
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi serializable nested public C
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.AbstractClassAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig abstract virtual 
+            instance int32  A1(int32 A_1,
+                               int32 A_2) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    } 
+
+    .method public hidebysig abstract virtual instance int32  A2(int32 A_1) cil managed
+    {
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_P() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.1
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig instance int32 
+            M1(int32 x,
+               int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public hidebysig instance !!a M2<a>(!!a x) cil managed preservesig
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .property instance int32 P()
+    {
+      .get instance int32 Program/C::get_P()
+    } 
+  } 
+
+  .class interface abstract auto ansi serializable nested public IInterface
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig abstract virtual instance int32  SomeMethod(int32 A_1) cil managed preservesig
+    {
+    } 
+
+  } 
+
+  .class sequential ansi serializable sealed nested public S
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype Program/S>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype Program/S>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .pack 0
+    .size 1
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig virtual final instance int32  CompareTo(valuetype Program/S obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (valuetype Program/S& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldc.i4.0
+      IL_0004:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  Program/S
+      IL_0007:  call       instance int32 Program/S::CompareTo(valuetype Program/S)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (valuetype Program/S V_0,
+               valuetype Program/S& V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  Program/S
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldc.i4.0
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 Program/S::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (object V_0,
+               valuetype Program/S V_1,
+               valuetype Program/S& V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     Program/S
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_0019
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  Program/S
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldc.i4.1
+      IL_0018:  ret
+
+      IL_0019:  ldc.i4.0
+      IL_001a:  ret
+    } 
+
+    .method public hidebysig instance !!a M1<a>(!!a x) cil managed preservesig
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(valuetype Program/S obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (valuetype Program/S& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldc.i4.1
+      IL_0004:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype Program/S V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     Program/S
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  Program/S
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool Program/S::Equals(valuetype Program/S)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+  } 
+
+  .class interface abstract auto ansi serializable nested public ITestInterface
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig abstract virtual instance int32  M(int32 A_1) cil managed
+    {
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname a@49
+         extends [runtime]System.Object
+         implements Program/ITestInterface
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method private hidebysig newslot virtual final instance int32  Program.ITestInterface.M(int32 x) cil managed
+    {
+      .custom instance void [System.Runtime.InteropServices]System.Runtime.InteropServices.PreserveSigAttribute::.ctor() = ( 01 00 00 00 ) 
+      .override Program/ITestInterface::M
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+  } 
+
+  .field static assembly class Program/ITestInterface a@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public static int32  f1(int32 x,
+                                  int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public static !!a  f2<a>(!!a x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ret
+  } 
+
+  .method public specialname static class Program/ITestInterface get_a() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class Program/ITestInterface Program::a@49
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  newobj     instance void Program/a@49::.ctor()
+    IL_0005:  stsfld     class Program/ITestInterface Program::a@49
+    IL_000a:  ret
+  } 
+
+  .property class Program/ITestInterface a()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class Program/ITestInterface Program::get_a()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Program
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Program::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompilerGeneratedAttributeOnAccessors.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompilerGeneratedAttributeOnAccessors.fs
index ec17c961cf2..2d2f4fdede3 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompilerGeneratedAttributeOnAccessors.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/CompilerGeneratedAttributeOnAccessors.fs
@@ -185,8 +185,14 @@ module ``Auto-generated accessors have CompilerGenerated attribute`` =
 // Regression: https://github.com/dotnet/fsharp/issues/14652
 module ``Let bindings in classes shoulnd't have DebuggerNonUserCodeAttribute`` =
 
-    [<Fact>]
-    let ``let binding doesn't have DebuggerNonUserCodeAttribute`` () =
+    let withRealInternalSignature realSig compilation =
+        compilation
+        |> withOptions [if realSig then "--realsig+" else "--realsig-" ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``let binding doesn't have DebuggerNonUserCodeAttribute`` (realSig) =
         FSharp
             """
             module Test
@@ -196,6 +202,7 @@ module ``Let bindings in classes shoulnd't have DebuggerNonUserCodeAttribute`` =
                 member this.Age
                     with get() = moo 9000
             """
+        |> withRealInternalSignature realSig
         |> compileAssembly
         |> getType "Test+User"
         |> getPrivateInstanceMethod "moo"
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr01.fs.RealInternalSignatureOff.il.bsl
similarity index 94%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr01.fs.RealInternalSignatureOff.il.bsl
index dabd1b0c57f..0ffa9021a8b 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr01.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr01.fs.RealInternalSignatureOff.il.bsl
@@ -54,8 +54,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -69,8 +68,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
     {
       
       .maxstack  8
@@ -84,8 +82,7 @@
 
   } 
 
-  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> 
-          get_res1() cil managed
+  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> get_res1() cil managed
   {
     
     .maxstack  8
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr01.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr01.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..b0676e7e397
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr01.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,157 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern ComputationExprLibrary
+{
+  .ver 0:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Program
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit res1@10
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res1@10::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res1@10::builder@
+      IL_0006:  ldc.i4.1
+      IL_0007:  tail.
+      IL_0009:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Return<int32>(!!0)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .field static assembly class [ComputationExprLibrary]Library.Eventually`1<int32> res1@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> get_res1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [ComputationExprLibrary]Library.Eventually`1<int32> Program::res1@8
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [ComputationExprLibrary]Library.EventuallyBuilder V_0,
+             class [ComputationExprLibrary]Library.Eventually`1<int32> V_1)
+    IL_0000:  call       class [ComputationExprLibrary]Library.EventuallyBuilder [ComputationExprLibrary]Library.TheEventuallyBuilder::get_eventually()
+    IL_0005:  stloc.0
+    IL_0006:  ldloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  newobj     instance void Program/res1@10::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder)
+    IL_000d:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<!!0>>)
+    IL_0012:  stsfld     class [ComputationExprLibrary]Library.Eventually`1<int32> Program::res1@8
+    IL_0017:  call       class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res1()
+    IL_001c:  stloc.1
+    IL_001d:  ldloc.1
+    IL_001e:  call       !!0 [ComputationExprLibrary]Library.EventuallyModule::force<int32>(class [ComputationExprLibrary]Library.Eventually`1<!!0>)
+    IL_0023:  pop
+    IL_0024:  ret
+  } 
+
+  .property class [ComputationExprLibrary]Library.Eventually`1<int32>
+          res1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res1()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Program
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Program::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr02.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr02.fs.RealInternalSignatureOff.il.bsl
similarity index 95%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr02.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr02.fs.RealInternalSignatureOff.il.bsl
index 997c267a7f4..6cd61a10cd0 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr02.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr02.fs.RealInternalSignatureOff.il.bsl
@@ -54,8 +54,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -69,8 +68,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
     {
       
       .maxstack  7
@@ -95,8 +93,7 @@
 
   } 
 
-  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> 
-          get_res2() cil managed
+  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> get_res2() cil managed
   {
     
     .maxstack  8
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr02.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr02.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..bf700dceabe
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr02.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,168 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern ComputationExprLibrary
+{
+  .ver 0:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Program
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit res2@9
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res2@9::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  nop
+      IL_0001:  ldstr      "hello"
+      IL_0006:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0010:  pop
+      IL_0011:  ldstr      "hello"
+      IL_0016:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_001b:  stloc.0
+      IL_001c:  ldarg.0
+      IL_001d:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res2@9::builder@
+      IL_0022:  ldloc.0
+      IL_0023:  ldloc.0
+      IL_0024:  add
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Return<int32>(!!0)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .field static assembly class [ComputationExprLibrary]Library.Eventually`1<int32> res2@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> get_res2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [ComputationExprLibrary]Library.Eventually`1<int32> Program::res2@7
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [ComputationExprLibrary]Library.EventuallyBuilder V_0,
+             class [ComputationExprLibrary]Library.Eventually`1<int32> V_1)
+    IL_0000:  call       class [ComputationExprLibrary]Library.EventuallyBuilder [ComputationExprLibrary]Library.TheEventuallyBuilder::get_eventually()
+    IL_0005:  stloc.0
+    IL_0006:  ldloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  newobj     instance void Program/res2@9::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder)
+    IL_000d:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<!!0>>)
+    IL_0012:  stsfld     class [ComputationExprLibrary]Library.Eventually`1<int32> Program::res2@7
+    IL_0017:  call       class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res2()
+    IL_001c:  stloc.1
+    IL_001d:  ldloc.1
+    IL_001e:  call       !!0 [ComputationExprLibrary]Library.EventuallyModule::force<int32>(class [ComputationExprLibrary]Library.Eventually`1<!!0>)
+    IL_0023:  pop
+    IL_0024:  ret
+  } 
+
+  .property class [ComputationExprLibrary]Library.Eventually`1<int32>
+          res2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res2()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Program
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Program::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr03.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr03.fs.RealInternalSignatureOff.il.bsl
similarity index 93%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr03.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr03.fs.RealInternalSignatureOff.il.bsl
index e0e48f1667a..f5f20503b19 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr03.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr03.fs.RealInternalSignatureOff.il.bsl
@@ -54,8 +54,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -69,8 +68,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
     {
       
       .maxstack  7
@@ -102,8 +100,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -117,8 +114,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
     {
       
       .maxstack  6
@@ -148,8 +144,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -163,8 +158,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> 
-            Invoke(int32 _arg2) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(int32 _arg2) cil managed
     {
       
       .maxstack  6
@@ -188,8 +182,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -203,8 +196,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> 
-            Invoke(int32 _arg1) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(int32 _arg1) cil managed
     {
       
       .maxstack  7
@@ -238,8 +230,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -253,8 +244,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
     {
       
       .maxstack  8
@@ -272,8 +262,7 @@
 
   } 
 
-  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> 
-          get_res2() cil managed
+  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> get_res2() cil managed
   {
     
     .maxstack  8
@@ -281,8 +270,7 @@
     IL_0005:  ret
   } 
 
-  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> 
-          get_res3() cil managed
+  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> get_res3() cil managed
   {
     
     .maxstack  8
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr03.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr03.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..50ce6ea0746
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr03.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,367 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern ComputationExprLibrary
+{
+  .ver 0:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Program
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit res2@9
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res2@9::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  nop
+      IL_0001:  ldstr      "hello"
+      IL_0006:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0010:  pop
+      IL_0011:  ldstr      "hello"
+      IL_0016:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_001b:  stloc.0
+      IL_001c:  ldarg.0
+      IL_001d:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res2@9::builder@
+      IL_0022:  ldloc.0
+      IL_0023:  ldloc.0
+      IL_0024:  add
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Return<int32>(!!0)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'res3@18-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res3@18-2'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0)
+      IL_0000:  nop
+      IL_0001:  ldstr      "hello"
+      IL_0006:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0010:  pop
+      IL_0011:  ldstr      "hello"
+      IL_0016:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_001b:  stloc.0
+      IL_001c:  ldarg.0
+      IL_001d:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res3@18-2'::builder@
+      IL_0022:  ldc.i4.1
+      IL_0023:  tail.
+      IL_0025:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Return<int32>(!!0)
+      IL_002a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'res3@21-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [ComputationExprLibrary]Library.Eventually`1<int32>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [ComputationExprLibrary]Library.Eventually`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res3@21-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(int32 _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res3@21-3'::builder@
+      IL_0008:  ldc.i4.1
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Return<int32>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'res3@16-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [ComputationExprLibrary]Library.Eventually`1<int32>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [ComputationExprLibrary]Library.Eventually`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res3@16-1'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [ComputationExprLibrary]Library.EventuallyBuilder V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res3@16-1'::builder@
+      IL_0008:  call       class [ComputationExprLibrary]Library.EventuallyBuilder [ComputationExprLibrary]Library.TheEventuallyBuilder::get_eventually()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  ldloc.1
+      IL_0010:  newobj     instance void Program/'res3@18-2'::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder)
+      IL_0015:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<!!0>>)
+      IL_001a:  ldarg.0
+      IL_001b:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res3@16-1'::builder@
+      IL_0020:  newobj     instance void Program/'res3@21-3'::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!1> [ComputationExprLibrary]Library.EventuallyBuilder::Bind<int32,int32>(class [ComputationExprLibrary]Library.Eventually`1<!!0>,
+                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [ComputationExprLibrary]Library.Eventually`1<!!1>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit res3@15
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res3@15::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res3@15::builder@
+      IL_0006:  call       class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res2()
+      IL_000b:  ldarg.0
+      IL_000c:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res3@15::builder@
+      IL_0011:  newobj     instance void Program/'res3@16-1'::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder)
+      IL_0016:  tail.
+      IL_0018:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!1> [ComputationExprLibrary]Library.EventuallyBuilder::Bind<int32,int32>(class [ComputationExprLibrary]Library.Eventually`1<!!0>,
+                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [ComputationExprLibrary]Library.Eventually`1<!!1>>)
+      IL_001d:  ret
+    } 
+
+  } 
+
+  .field static assembly class [ComputationExprLibrary]Library.Eventually`1<int32> res2@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [ComputationExprLibrary]Library.Eventually`1<int32> res3@13
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> get_res2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [ComputationExprLibrary]Library.Eventually`1<int32> Program::res2@7
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> get_res3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [ComputationExprLibrary]Library.Eventually`1<int32> Program::res3@13
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [ComputationExprLibrary]Library.EventuallyBuilder V_0,
+             class [ComputationExprLibrary]Library.Eventually`1<int32> V_1,
+             class [ComputationExprLibrary]Library.EventuallyBuilder V_2,
+             class [ComputationExprLibrary]Library.Eventually`1<int32> V_3)
+    IL_0000:  call       class [ComputationExprLibrary]Library.EventuallyBuilder [ComputationExprLibrary]Library.TheEventuallyBuilder::get_eventually()
+    IL_0005:  stloc.0
+    IL_0006:  ldloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  newobj     instance void Program/res2@9::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder)
+    IL_000d:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<!!0>>)
+    IL_0012:  stsfld     class [ComputationExprLibrary]Library.Eventually`1<int32> Program::res2@7
+    IL_0017:  call       class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res2()
+    IL_001c:  stloc.1
+    IL_001d:  ldloc.1
+    IL_001e:  call       !!0 [ComputationExprLibrary]Library.EventuallyModule::force<int32>(class [ComputationExprLibrary]Library.Eventually`1<!!0>)
+    IL_0023:  pop
+    IL_0024:  call       class [ComputationExprLibrary]Library.EventuallyBuilder [ComputationExprLibrary]Library.TheEventuallyBuilder::get_eventually()
+    IL_0029:  stloc.2
+    IL_002a:  ldloc.2
+    IL_002b:  ldloc.2
+    IL_002c:  newobj     instance void Program/res3@15::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder)
+    IL_0031:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<!!0>>)
+    IL_0036:  stsfld     class [ComputationExprLibrary]Library.Eventually`1<int32> Program::res3@13
+    IL_003b:  call       class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res3()
+    IL_0040:  stloc.3
+    IL_0041:  ldloc.3
+    IL_0042:  call       !!0 [ComputationExprLibrary]Library.EventuallyModule::force<int32>(class [ComputationExprLibrary]Library.Eventually`1<!!0>)
+    IL_0047:  pop
+    IL_0048:  ret
+  } 
+
+  .property class [ComputationExprLibrary]Library.Eventually`1<int32>
+          res2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res2()
+  } 
+  .property class [ComputationExprLibrary]Library.Eventually`1<int32>
+          res3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res3()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Program
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Program::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr04.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr04.fs.RealInternalSignatureOff.il.bsl
similarity index 93%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr04.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr04.fs.RealInternalSignatureOff.il.bsl
index 09fdff46070..64e755d264f 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr04.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr04.fs.RealInternalSignatureOff.il.bsl
@@ -54,8 +54,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -69,8 +68,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
     {
       
       .maxstack  6
@@ -116,8 +114,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -131,8 +128,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> 
-            Invoke(class [runtime]System.Exception _arg1) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [runtime]System.Exception _arg1) cil managed
     {
       
       .maxstack  6
@@ -165,8 +161,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -180,8 +175,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
     {
       
       .maxstack  8
@@ -204,8 +198,7 @@
 
   } 
 
-  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> 
-          get_res4() cil managed
+  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> get_res4() cil managed
   {
     
     .maxstack  8
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr04.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr04.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..5b286edf1c4
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr04.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,273 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern ComputationExprLibrary
+{
+  .ver 0:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Program
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'res4@8-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res4@8-1'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               string V_1)
+      IL_0000:  nop
+      IL_0001:  nop
+      IL_0002:  ldstr      "hello"
+      IL_0007:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_000c:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0011:  pop
+      IL_0012:  ldstr      "hello"
+      IL_0017:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_001c:  stloc.0
+      IL_001d:  ldstr      "fail"
+      IL_0022:  stloc.1
+      IL_0023:  ldc.i4.0
+      IL_0024:  brfalse.s  IL_002e
+
+      IL_0026:  ldnull
+      IL_0027:  unbox.any  [FSharp.Core]Microsoft.FSharp.Core.Unit
+      IL_002c:  br.s       IL_0035
+
+      IL_002e:  ldloc.1
+      IL_002f:  call       class [runtime]System.Exception [FSharp.Core]Microsoft.FSharp.Core.Operators::Failure(string)
+      IL_0034:  throw
+
+      IL_0035:  pop
+      IL_0036:  ldarg.0
+      IL_0037:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res4@8-1'::builder@
+      IL_003c:  ldloc.0
+      IL_003d:  tail.
+      IL_003f:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Return<int32>(!!0)
+      IL_0044:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'res4@7-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Exception,class [ComputationExprLibrary]Library.Eventually`1<int32>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Exception,class [ComputationExprLibrary]Library.Eventually`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res4@7-2'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [runtime]System.Exception _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               int32 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  nop
+      IL_0003:  ldstr      "hello"
+      IL_0008:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_000d:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0012:  pop
+      IL_0013:  ldstr      "hello"
+      IL_0018:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_001d:  stloc.1
+      IL_001e:  ldarg.0
+      IL_001f:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res4@7-2'::builder@
+      IL_0024:  ldloc.1
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Return<int32>(!!0)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit res4@7
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res4@7::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res4@7::builder@
+      IL_0006:  ldarg.0
+      IL_0007:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res4@7::builder@
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res4@7::builder@
+      IL_0012:  newobj     instance void Program/'res4@8-1'::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder)
+      IL_0017:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<!!0>>)
+      IL_001c:  ldarg.0
+      IL_001d:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res4@7::builder@
+      IL_0022:  newobj     instance void Program/'res4@7-2'::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder)
+      IL_0027:  tail.
+      IL_0029:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::TryWith<int32>(class [ComputationExprLibrary]Library.Eventually`1<!!0>,
+                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Exception,class [ComputationExprLibrary]Library.Eventually`1<!!0>>)
+      IL_002e:  ret
+    } 
+
+  } 
+
+  .field static assembly class [ComputationExprLibrary]Library.Eventually`1<int32> res4@5
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> get_res4() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [ComputationExprLibrary]Library.Eventually`1<int32> Program::res4@5
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [ComputationExprLibrary]Library.EventuallyBuilder V_0,
+             class [ComputationExprLibrary]Library.Eventually`1<int32> V_1)
+    IL_0000:  call       class [ComputationExprLibrary]Library.EventuallyBuilder [ComputationExprLibrary]Library.TheEventuallyBuilder::get_eventually()
+    IL_0005:  stloc.0
+    IL_0006:  ldloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  newobj     instance void Program/res4@7::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder)
+    IL_000d:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<!!0>>)
+    IL_0012:  stsfld     class [ComputationExprLibrary]Library.Eventually`1<int32> Program::res4@5
+    IL_0017:  call       class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res4()
+    IL_001c:  stloc.1
+    IL_001d:  ldloc.1
+    IL_001e:  call       !!0 [ComputationExprLibrary]Library.EventuallyModule::force<int32>(class [ComputationExprLibrary]Library.Eventually`1<!!0>)
+    IL_0023:  pop
+    IL_0024:  ret
+  } 
+
+  .property class [ComputationExprLibrary]Library.Eventually`1<int32>
+          res4()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res4()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Program
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Program::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr05.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr05.fs.RealInternalSignatureOff.il.bsl
similarity index 93%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr05.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr05.fs.RealInternalSignatureOff.il.bsl
index 062fefa2572..1868fb32858 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr05.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr05.fs.RealInternalSignatureOff.il.bsl
@@ -52,8 +52,7 @@
          implements [runtime]System.IDisposable
   {
     .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
-    .method public specialname rtspecialname 
-            instance void  .ctor() cil managed
+    .method public specialname rtspecialname instance void  .ctor() cil managed
     {
       
       .maxstack  8
@@ -64,8 +63,7 @@
       IL_0008:  ret
     } 
 
-    .method private hidebysig newslot virtual final 
-            instance void  System.IDisposable.Dispose() cil managed
+    .method private hidebysig newslot virtual final instance void  System.IDisposable.Dispose() cil managed
     {
       .override [runtime]System.IDisposable::Dispose
       
@@ -85,8 +83,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -100,8 +97,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> 
-            Invoke(class [runtime]System.IDisposable _arg1) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [runtime]System.IDisposable _arg1) cil managed
     {
       
       .maxstack  6
@@ -134,8 +130,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -149,8 +144,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
     {
       
       .maxstack  7
@@ -178,8 +172,7 @@
 
   } 
 
-  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> 
-          get_res5() cil managed
+  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> get_res5() cil managed
   {
     
     .maxstack  8
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr05.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr05.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..9e005d2638d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr05.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,247 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern ComputationExprLibrary
+{
+  .ver 0:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Program
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'res5@10-1'
+         extends [runtime]System.Object
+         implements [runtime]System.IDisposable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method private hidebysig newslot virtual final instance void  System.IDisposable.Dispose() cil managed
+    {
+      .override [runtime]System.IDisposable::Dispose
+      
+      .maxstack  4
+      .locals init (class [runtime]System.IDisposable V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  stloc.0
+      IL_0002:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'res5@11-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.IDisposable,class [ComputationExprLibrary]Library.Eventually`1<int32>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.IDisposable,class [ComputationExprLibrary]Library.Eventually`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res5@11-2'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [runtime]System.IDisposable _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.IDisposable V_0,
+               int32 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  nop
+      IL_0003:  ldstr      "hello"
+      IL_0008:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_000d:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0012:  pop
+      IL_0013:  ldstr      "hello"
+      IL_0018:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_001d:  stloc.1
+      IL_001e:  ldarg.0
+      IL_001f:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res5@11-2'::builder@
+      IL_0024:  ldc.i4.1
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Return<int32>(!!0)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit res5@9
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res5@9::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  nop
+      IL_0001:  nop
+      IL_0002:  ldstr      "hello"
+      IL_0007:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_000c:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0011:  pop
+      IL_0012:  ldstr      "hello"
+      IL_0017:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_001c:  stloc.0
+      IL_001d:  ldarg.0
+      IL_001e:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res5@9::builder@
+      IL_0023:  newobj     instance void Program/'res5@10-1'::.ctor()
+      IL_0028:  ldarg.0
+      IL_0029:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res5@9::builder@
+      IL_002e:  newobj     instance void Program/'res5@11-2'::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder)
+      IL_0033:  tail.
+      IL_0035:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Using<int32>(class [runtime]System.IDisposable,
+                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.IDisposable,class [ComputationExprLibrary]Library.Eventually`1<!!0>>)
+      IL_003a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [ComputationExprLibrary]Library.Eventually`1<int32> res5@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> get_res5() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [ComputationExprLibrary]Library.Eventually`1<int32> Program::res5@7
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [ComputationExprLibrary]Library.EventuallyBuilder V_0,
+             class [ComputationExprLibrary]Library.Eventually`1<int32> V_1)
+    IL_0000:  call       class [ComputationExprLibrary]Library.EventuallyBuilder [ComputationExprLibrary]Library.TheEventuallyBuilder::get_eventually()
+    IL_0005:  stloc.0
+    IL_0006:  ldloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  newobj     instance void Program/res5@9::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder)
+    IL_000d:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<!!0>>)
+    IL_0012:  stsfld     class [ComputationExprLibrary]Library.Eventually`1<int32> Program::res5@7
+    IL_0017:  call       class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res5()
+    IL_001c:  stloc.1
+    IL_001d:  ldloc.1
+    IL_001e:  call       !!0 [ComputationExprLibrary]Library.EventuallyModule::force<int32>(class [ComputationExprLibrary]Library.Eventually`1<!!0>)
+    IL_0023:  pop
+    IL_0024:  ret
+  } 
+
+  .property class [ComputationExprLibrary]Library.Eventually`1<int32>
+          res5()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res5()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Program
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Program::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr06.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr06.fs.RealInternalSignatureOff.il.bsl
similarity index 94%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr06.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr06.fs.RealInternalSignatureOff.il.bsl
index c1cb4280c84..5553e1bfff9 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr06.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr06.fs.RealInternalSignatureOff.il.bsl
@@ -51,8 +51,7 @@
          extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,bool>
   {
     .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -66,8 +65,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance bool 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    .method public strict virtual instance bool Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
     {
       
       .maxstack  8
@@ -108,8 +106,7 @@
       IL_0014:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
     {
       
       .maxstack  7
@@ -157,8 +154,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -172,8 +168,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
     {
       
       .maxstack  8
@@ -194,8 +189,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -209,8 +203,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
     {
       
       .maxstack  10
@@ -248,8 +241,7 @@
 
   } 
 
-  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> 
-          get_res6() cil managed
+  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> get_res6() cil managed
   {
     
     .maxstack  8
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr06.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr06.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..be250545d89
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr06.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,320 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern ComputationExprLibrary
+{
+  .ver 0:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Program
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'res6@10-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,bool>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,bool>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> Program/'res6@10-1'::x
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> Program/'res6@10-1'::x
+      IL_0006:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+      IL_000b:  ldc.i4.0
+      IL_000c:  cgt
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'res6@11-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@,
+                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res6@11-2'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> Program/'res6@11-2'::x
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  7
+      IL_0000:  ldstr      "hello"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_000f:  pop
+      IL_0010:  ldstr      "hello"
+      IL_0015:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_001a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_001f:  pop
+      IL_0020:  ldstr      "hello"
+      IL_0025:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_002a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_002f:  pop
+      IL_0030:  ldstr      "hello"
+      IL_0035:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_003a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_003f:  pop
+      IL_0040:  ldstr      "hello"
+      IL_0045:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_004a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_004f:  pop
+      IL_0050:  ldarg.0
+      IL_0051:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> Program/'res6@11-2'::x
+      IL_0056:  ldarg.0
+      IL_0057:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> Program/'res6@11-2'::x
+      IL_005c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+      IL_0061:  ldc.i4.1
+      IL_0062:  sub
+      IL_0063:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_contents(!0)
+      IL_0068:  ldarg.0
+      IL_0069:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res6@11-2'::builder@
+      IL_006e:  tail.
+      IL_0070:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [ComputationExprLibrary]Library.EventuallyBuilder::Zero()
+      IL_0075:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'res6@17-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res6@17-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res6@17-3'::builder@
+      IL_0006:  ldc.i4.1
+      IL_0007:  tail.
+      IL_0009:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Return<int32>(!!0)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit res6@9
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res6@9::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_0)
+      IL_0000:  ldc.i4.1
+      IL_0001:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::.ctor(!0)
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res6@9::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res6@9::builder@
+      IL_0013:  ldloc.0
+      IL_0014:  newobj     instance void Program/'res6@10-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res6@9::builder@
+      IL_001f:  ldarg.0
+      IL_0020:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res6@9::builder@
+      IL_0025:  ldloc.0
+      IL_0026:  newobj     instance void Program/'res6@11-2'::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder,
+                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>)
+      IL_002b:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Delay<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<!!0>>)
+      IL_0030:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [ComputationExprLibrary]Library.EventuallyBuilder::While(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,bool>,
+                                                                                                                                                                                               class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0035:  ldarg.0
+      IL_0036:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res6@9::builder@
+      IL_003b:  ldarg.0
+      IL_003c:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res6@9::builder@
+      IL_0041:  newobj     instance void Program/'res6@17-3'::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder)
+      IL_0046:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<!!0>>)
+      IL_004b:  tail.
+      IL_004d:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Combine<int32>(class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>,
+                                                                                                                                                              class [ComputationExprLibrary]Library.Eventually`1<!!0>)
+      IL_0052:  ret
+    } 
+
+  } 
+
+  .field static assembly class [ComputationExprLibrary]Library.Eventually`1<int32> res6@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> get_res6() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [ComputationExprLibrary]Library.Eventually`1<int32> Program::res6@7
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [ComputationExprLibrary]Library.EventuallyBuilder V_0,
+             class [ComputationExprLibrary]Library.Eventually`1<int32> V_1,
+             int32 V_2,
+             int32 V_3)
+    IL_0000:  call       class [ComputationExprLibrary]Library.EventuallyBuilder [ComputationExprLibrary]Library.TheEventuallyBuilder::get_eventually()
+    IL_0005:  stloc.0
+    IL_0006:  ldloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  newobj     instance void Program/res6@9::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder)
+    IL_000d:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<!!0>>)
+    IL_0012:  stsfld     class [ComputationExprLibrary]Library.Eventually`1<int32> Program::res6@7
+    IL_0017:  call       class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res6()
+    IL_001c:  stloc.1
+    IL_001d:  ldloc.1
+    IL_001e:  call       !!0 [ComputationExprLibrary]Library.EventuallyModule::force<int32>(class [ComputationExprLibrary]Library.Eventually`1<!!0>)
+    IL_0023:  stloc.2
+    IL_0024:  ldloc.2
+    IL_0025:  stloc.3
+    IL_0026:  ret
+  } 
+
+  .property class [ComputationExprLibrary]Library.Eventually`1<int32>
+          res6()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res6()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Program
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Program::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr07.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr07.fs.RealInternalSignatureOff.il.bsl
similarity index 96%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr07.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr07.fs.RealInternalSignatureOff.il.bsl
index 6b0f84999c2..ddc2e25a3e9 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr07.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr07.fs.RealInternalSignatureOff.il.bsl
@@ -74,8 +74,7 @@
       IL_0014:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> 
-            Invoke(int32 _arg1) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(int32 _arg1) cil managed
     {
       
       .maxstack  7
@@ -126,8 +125,7 @@
       IL_0014:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
     {
       
       .maxstack  8
@@ -150,8 +148,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -165,8 +162,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
     {
       
       .maxstack  9
@@ -182,8 +178,8 @@
       IL_0014:  ldc.i4.1
       IL_0015:  ldc.i4.3
       IL_0016:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
-                                                                                                                                                                             int32,
-                                                                                                                                                                             int32)
+                                                                                                                                                                       int32,
+                                                                                                                                                                       int32)
       IL_001b:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::CreateSequence<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
       IL_0020:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
       IL_0025:  ldarg.0
@@ -209,8 +205,7 @@
 
   } 
 
-  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> 
-          get_res7() cil managed
+  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> get_res7() cil managed
   {
     
     .maxstack  8
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr07.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr07.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..8e72593dcde
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpr07.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,284 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern ComputationExprLibrary
+{
+  .ver 0:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Program
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'res7@10-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@,
+                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res7@10-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> Program/'res7@10-1'::x
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> Program/'res7@10-1'::x
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> Program/'res7@10-1'::x
+      IL_000e:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+      IL_0013:  ldloc.0
+      IL_0014:  sub
+      IL_0015:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_contents(!0)
+      IL_001a:  ldarg.0
+      IL_001b:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res7@10-1'::builder@
+      IL_0020:  tail.
+      IL_0022:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [ComputationExprLibrary]Library.EventuallyBuilder::Zero()
+      IL_0027:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'res7@12-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@,
+                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res7@12-2'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> Program/'res7@12-2'::x
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/'res7@12-2'::builder@
+      IL_0006:  ldarg.0
+      IL_0007:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> Program/'res7@12-2'::x
+      IL_000c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+      IL_0011:  tail.
+      IL_0013:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Return<int32>(!!0)
+      IL_0018:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit res7@9
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>
+  {
+    .field public class [ComputationExprLibrary]Library.EventuallyBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [ComputationExprLibrary]Library.EventuallyBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res7@9::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [ComputationExprLibrary]Library.Eventually`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_0)
+      IL_0000:  ldc.i4.1
+      IL_0001:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::.ctor(!0)
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res7@9::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res7@9::builder@
+      IL_0013:  ldc.i4.0
+      IL_0014:  ldc.i4.1
+      IL_0015:  ldc.i4.3
+      IL_0016:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                       int32,
+                                                                                                                                                                       int32)
+      IL_001b:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::CreateSequence<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0020:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0025:  ldarg.0
+      IL_0026:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res7@9::builder@
+      IL_002b:  ldloc.0
+      IL_002c:  newobj     instance void Program/'res7@10-1'::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder,
+                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>)
+      IL_0031:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit> [ComputationExprLibrary]Library.EventuallyBuilder::For<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>>)
+      IL_0036:  ldarg.0
+      IL_0037:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res7@9::builder@
+      IL_003c:  ldarg.0
+      IL_003d:  ldfld      class [ComputationExprLibrary]Library.EventuallyBuilder Program/res7@9::builder@
+      IL_0042:  ldloc.0
+      IL_0043:  newobj     instance void Program/'res7@12-2'::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder,
+                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>)
+      IL_0048:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<!!0>>)
+      IL_004d:  tail.
+      IL_004f:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Combine<int32>(class [ComputationExprLibrary]Library.Eventually`1<class [FSharp.Core]Microsoft.FSharp.Core.Unit>,
+                                                                                                                                                              class [ComputationExprLibrary]Library.Eventually`1<!!0>)
+      IL_0054:  ret
+    } 
+
+  } 
+
+  .field static assembly class [ComputationExprLibrary]Library.Eventually`1<int32> res7@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [ComputationExprLibrary]Library.Eventually`1<int32> get_res7() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [ComputationExprLibrary]Library.Eventually`1<int32> Program::res7@7
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Program::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [ComputationExprLibrary]Library.EventuallyBuilder V_0,
+             class [ComputationExprLibrary]Library.Eventually`1<int32> V_1,
+             int32 V_2,
+             int32 V_3)
+    IL_0000:  call       class [ComputationExprLibrary]Library.EventuallyBuilder [ComputationExprLibrary]Library.TheEventuallyBuilder::get_eventually()
+    IL_0005:  stloc.0
+    IL_0006:  ldloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  newobj     instance void Program/res7@9::.ctor(class [ComputationExprLibrary]Library.EventuallyBuilder)
+    IL_000d:  callvirt   instance class [ComputationExprLibrary]Library.Eventually`1<!!0> [ComputationExprLibrary]Library.EventuallyBuilder::Delay<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [ComputationExprLibrary]Library.Eventually`1<!!0>>)
+    IL_0012:  stsfld     class [ComputationExprLibrary]Library.Eventually`1<int32> Program::res7@7
+    IL_0017:  call       class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res7()
+    IL_001c:  stloc.1
+    IL_001d:  ldloc.1
+    IL_001e:  call       !!0 [ComputationExprLibrary]Library.EventuallyModule::force<int32>(class [ComputationExprLibrary]Library.Eventually`1<!!0>)
+    IL_0023:  stloc.2
+    IL_0024:  ldloc.2
+    IL_0025:  stloc.3
+    IL_0026:  ret
+  } 
+
+  .property class [ComputationExprLibrary]Library.Eventually`1<int32>
+          res7()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [ComputationExprLibrary]Library.Eventually`1<int32> Program::get_res7()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Program
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Program::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpressions.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpressions.fs
index e75263be3e9..b1e8ca4f4c8 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpressions.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ComputationExpressions/ComputationExpressions.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open System.IO
 open Xunit
@@ -7,9 +7,18 @@ open FSharp.Test.Compiler
 
 module ComputationExpressions =
 
+    let withRealInternalSignature compilation =
+        compilation
+        |> withOptions ["--realsig+"]
+
+    let withoutRealInternalSignature compilation =
+        compilation
+        |> withOptions ["--realsig-"]
+
     let computationExprLibrary =
         FsFromPath (Path.Combine(__SOURCE_DIRECTORY__,  "ComputationExprLibrary.fs"))
         |> withName "ComputationExprLibrary"
+        |> withoutRealInternalSignature
 
     let verifyCompilation compilation =
         compilation
@@ -23,37 +32,86 @@ module ComputationExpressions =
         |> ignoreWarnings
         |> verifyILBaseline
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ComputationExpr01.fs"|])>]
-    let ``ComputationExpr01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ComputationExpr01.fs"|])>]
+    let ``ComputationExpr01_realsig=true`` compilation =
+        compilation
+        |> withRealInternalSignature
+        |> verifyCompilation
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ComputationExpr01.fs"|])>]
+    let ``ComputationExpr01_realsig=false`` compilation =
+        compilation
+        |> withoutRealInternalSignature
+        |> verifyCompilation
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ComputationExpr02.fs"|])>]
+    let ``ComputationExpr02_realsig=true`` compilation =
+        compilation
+        |> withRealInternalSignature
+        |> verifyCompilation
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ComputationExpr02.fs"|])>]
+    let ``ComputationExpr02_realsig=false`` compilation =
         compilation
+        |> withoutRealInternalSignature
         |> verifyCompilation
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ComputationExpr02.fs"|])>]
-    let ``ComputationExpr02_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ComputationExpr03.fs"|])>]
+    let ``ComputationExpr03_realsig=true`` compilation =
         compilation
+        |> withRealInternalSignature
         |> verifyCompilation
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ComputationExpr03.fs"|])>]
-    let ``ComputationExpr03_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ComputationExpr03.fs"|])>]
+    let ``ComputationExpr03_realsig=false`` compilation =
         compilation
+        |> withoutRealInternalSignature
         |> verifyCompilation
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ComputationExpr04.fs"|])>]
-    let ``ComputationExpr04_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ComputationExpr04.fs"|])>]
+    let ``ComputationExpr04_realsig=true`` compilation =
+        compilation
+        |> withRealInternalSignature
+        |> verifyCompilation 
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ComputationExpr04.fs"|])>]
+    let ``ComputationExpr04_realsig=false`` compilation =
+        compilation
+        |> withoutRealInternalSignature
+        |> verifyCompilation 
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ComputationExpr05.fs"|])>]
+    let ``ComputationExpr05_realsig=true`` compilation =
+        compilation
+        |> withRealInternalSignature
+        |> verifyCompilation 
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ComputationExpr05.fs"|])>]
+    let ``ComputationExpr05_realsig=false`` compilation =
+        compilation
+        |> withoutRealInternalSignature
+        |> verifyCompilation 
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ComputationExpr06.fs"|])>]
+    let ``ComputationExpr06_realsig=true`` compilation =
         compilation
+        |> withRealInternalSignature
         |> verifyCompilation 
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ComputationExpr05.fs"|])>]
-    let ``ComputationExpr05_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ComputationExpr06.fs"|])>]
+    let ``ComputationExpr06_realsig=false`` compilation =
         compilation
+        |> withoutRealInternalSignature
         |> verifyCompilation 
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ComputationExpr06.fs"|])>]
-    let ``ComputationExpr06_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ComputationExpr07.fs"|])>]
+    let ``ComputationExpr07_realsig=true`` compilation =
         compilation
+        |> withRealInternalSignature
         |> verifyCompilation 
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ComputationExpr07.fs"|])>]
-    let ``ComputationExpr07_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ComputationExpr07.fs"|])>]
+    let ``ComputationExpr07_realsig=false`` compilation =
         compilation
+        |> withoutRealInternalSignature
         |> verifyCompilation 
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/FixedBindings/FixedBindings.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/FixedBindings/FixedBindings.fs
index 93ef808ce36..9f1c66decee 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/FixedBindings/FixedBindings.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/FixedBindings/FixedBindings.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL.FixedBindings
+namespace EmittedIL
 
 open System.Reflection
 open Microsoft.FSharp.NativeInterop
@@ -8,7 +8,7 @@ open FSharp.Test
 open FSharp.Test.Utilities
 open FSharp.Test.Compiler
 
-module Legacy =
+module FixedBindings =
     [<Theory>]
     [<InlineData("7.0")>]
     let ``Pin naked string`` langVersion =
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnArray01.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnArray01.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnArray01.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnArray01.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnArray01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnArray01.fs.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnArray01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnArray01.fs.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnList01.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnList01.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnList01.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnList01.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnList01.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnList01.fs.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnList01.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnList01.fs.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnList01.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnList01.fs.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnList01.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnList01.fs.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnList01.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnList01.fs.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnList01.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnList01.fs.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnList01.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnList01.fs.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnList01.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnList01.fs.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnString01.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnString01.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnString01.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnString01.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnString01.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnString01.fs.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnString01.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnString01.fs.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnString01.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnString01.fs.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnString01.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnString01.fs.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnString01.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnString01.fs.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnString01.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnString01.fs.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnString01.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnString01.fs.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForEachOnString01.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForEachOnString01.fs.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForLoop.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForLoop.fs
new file mode 100644
index 00000000000..d670348ae71
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ForLoop.fs
@@ -0,0 +1,133 @@
+namespace EmittedIL.RealInternalSignature
+
+open Xunit
+open FSharp.Test
+open FSharp.Test.Compiler
+
+module ForLoopRealInternalSignatureOff =
+
+    let verifyCompilation compilation =
+        compilation
+        |> withOptions [ "--test:EmitFeeFeeAs100001" ]
+        |> asExe
+        |> withOptimize
+        |> withEmbeddedPdb
+        |> withEmbedAllSource
+        |> ignoreWarnings
+        |> withRealInternalSignatureOff
+        |> verifyILBaseline
+
+    // SOURCE=NoAllocationOfTuple01.fs SCFLAGS="-a -g --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd NoAllocationOfTuple01.dll" # NoAllocationOfTuple01.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"NoAllocationOfTuple01.fs"|])>]
+    let ``NoAllocationOfTuple01_fs`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=ForEachOnArray01.fs      SCFLAGS="-a -g --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ForEachOnArray01.dll"      # ForEachOnArray01.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ForEachOnArray01.fs"|])>]
+    let ``ForEachOnArray01_fs`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=ForEachOnList01.fs       SCFLAGS="-a -g --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ForEachOnList01.dll"       # ForEachOnList01.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ForEachOnList01.fs"|])>]
+    let ``ForEachOnList01_fs`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=ForEachOnString01.fs     SCFLAGS="-a -g --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ForEachOnString01.dll"     # ForEachOnString01.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ForEachOnString01.fs"|])>]
+    let ``ForEachOnString01_fs`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=ZeroToArrLength01.fs     SCFLAGS="-a -g --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ZeroToArrLength01.dll"     # ZeroToArrLength01.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ZeroToArrLength01.fs"|])>]
+    let ``ZeroToArrLength01_fs`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=ZeroToArrLength02.fs     SCFLAGS="-a -g --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ZeroToArrLength02.dll"     # ZeroToArrLength02.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ZeroToArrLength02.fs"|])>]
+    let ``ZeroToArrLength02_fs`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=NoIEnumerable01.fsx SCFLAGS="-a -g --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd NoIEnumerable01.dll"            # NoIEnumerable01.fsx
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"NoIEnumerable01.fsx"|])>]
+    let ``NoIEnumerable01_fsx`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=NoIEnumerable02.fsx SCFLAGS="-a -g --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd NoIEnumerable02.dll"            # NoIEnumerable02.fsx
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"NoIEnumerable02.fsx"|])>]
+    let ``NoIEnumerable02_fsx`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=NoIEnumerable03.fsx SCFLAGS="-a -g --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd NoIEnumerable03.dll"            # NoIEnumerable03.fsx
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"NoIEnumerable03.fsx"|])>]
+    let ``NoIEnumerable03_fsx`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=NonTrivialBranchingBindingInEnd01.fs SCFLAGS="--optimize+"	# NonTrivialBranchingBindingInEnd01.fs --optimize+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".opt", Includes=[|"NonTrivialBranchingBindingInEnd01.fs"|])>]
+    let ``NonTrivialBranchingBindingInEnd01_fs_opt`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=NonTrivialBranchingBindingInEnd01.fs SCFLAGS="--optimize-"	# NonTrivialBranchingBindingInEnd01.fs --optimize-
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"NonTrivialBranchingBindingInEnd01.fs"|])>]
+    let ``NonTrivialBranchingBindingInEnd01_fs_nonopt`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=NonTrivialBranchingBindingInEnd02.fs SCFLAGS="--optimize+"	# NonTrivialBranchingBindingInEnd02.fs --optimize+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".opt", Includes=[|"NonTrivialBranchingBindingInEnd02.fs"|])>]
+    let ``NonTrivialBranchingBindingInEnd02_fs_opt`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=NonTrivialBranchingBindingInEnd02.fs SCFLAGS="--optimize-"	# NonTrivialBranchingBindingInEnd02.fs --optimize-
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"NonTrivialBranchingBindingInEnd02.fs"|])>]
+    let ``NonTrivialBranchingBindingInEnd02_fs_nonopt`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=NonTrivialBranchingBindingInEnd03.fs SCFLAGS="--optimize+"	# NonTrivialBranchingBindingInEnd03.fs --optimize+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".opt", Includes=[|"NonTrivialBranchingBindingInEnd03.fs"|])>]
+    let ``NonTrivialBranchingBindingInEnd03_fs_opt`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=NonTrivialBranchingBindingInEnd03.fs SCFLAGS="--optimize-"	# NonTrivialBranchingBindingInEnd03.fs --optimize-
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"NonTrivialBranchingBindingInEnd03.fs"|])>]
+    let ``NonTrivialBranchingBindingInEnd03_fs_nonopt`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=NonTrivialBranchingBindingInEnd04.fs SCFLAGS="--optimize+"	# NonTrivialBranchingBindingInEnd04.fs --optimize+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".opt", Includes=[|"NonTrivialBranchingBindingInEnd04.fs"|])>]
+    let ``NonTrivialBranchingBindingInEnd04_fs_opt`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=NonTrivialBranchingBindingInEnd04.fs SCFLAGS="--optimize-"	# NonTrivialBranchingBindingInEnd04.fs --optimize-
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"NonTrivialBranchingBindingInEnd04.fs"|])>]
+    let ``NonTrivialBranchingBindingInEnd04_fs_nonopt`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=NonTrivialBranchingBindingInEnd05.fs SCFLAGS="--optimize+"	# NonTrivialBranchingBindingInEnd05.fs --optimize+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".opt", Includes=[|"NonTrivialBranchingBindingInEnd05.fs"|])>]
+    let ``NonTrivialBranchingBindingInEnd05_fs_opt`` compilation =
+        compilation
+        |> verifyCompilation
+
+    // SOURCE=NonTrivialBranchingBindingInEnd05.fs SCFLAGS="--optimize-"	# NonTrivialBranchingBindingInEnd05.fs --optimize-
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"NonTrivialBranchingBindingInEnd05.fs"|])>]
+    let ``NonTrivialBranchingBindingInEnd05_fs_nonopt`` compilation =
+        compilation
+        |> verifyCompilation
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoAllocationOfTuple01.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoAllocationOfTuple01.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoAllocationOfTuple01.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoAllocationOfTuple01.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoAllocationOfTuple01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoAllocationOfTuple01.fs.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoAllocationOfTuple01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoAllocationOfTuple01.fs.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable01.fsx b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable01.fsx
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable01.fsx
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable01.fsx
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable01.fsx.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable01.fsx.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable01.fsx.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable01.fsx.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable01.fsx.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable01.fsx.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable01.fsx.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable01.fsx.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable01.fsx.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable01.fsx.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable01.fsx.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable01.fsx.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable01.fsx.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable01.fsx.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable01.fsx.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable01.fsx.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable02.fsx b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable02.fsx
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable02.fsx
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable02.fsx
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable02.fsx.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable02.fsx.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable02.fsx.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable02.fsx.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable02.fsx.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable02.fsx.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable02.fsx.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable02.fsx.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable02.fsx.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable02.fsx.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable02.fsx.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable02.fsx.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable02.fsx.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable02.fsx.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable02.fsx.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable02.fsx.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable03.fsx b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable03.fsx
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable03.fsx
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable03.fsx
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable03.fsx.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable03.fsx.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable03.fsx.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable03.fsx.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable03.fsx.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable03.fsx.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable03.fsx.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable03.fsx.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable03.fsx.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable03.fsx.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable03.fsx.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable03.fsx.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable03.fsx.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable03.fsx.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NoIEnumerable03.fsx.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NoIEnumerable03.fsx.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd01.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd01.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd01.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd01.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd01.fs.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd01.fs.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd01.fs.opt.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd01.fs.opt.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd01.fs.opt.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd01.fs.opt.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd02.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd02.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd02.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd02.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd02.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd02.fs.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd02.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd02.fs.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd02.fs.opt.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd02.fs.opt.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd02.fs.opt.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd02.fs.opt.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd03.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd03.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd03.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd03.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd03.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd03.fs.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd03.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd03.fs.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd03.fs.opt.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd03.fs.opt.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd03.fs.opt.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd03.fs.opt.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd04.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd04.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd04.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd04.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd04.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd04.fs.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd04.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd04.fs.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd04.fs.opt.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd04.fs.opt.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd04.fs.opt.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd04.fs.opt.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd05.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd05.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd05.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd05.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd05.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd05.fs.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd05.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd05.fs.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd05.fs.opt.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd05.fs.opt.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/NonTrivialBranchingBindingInEnd05.fs.opt.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/NonTrivialBranchingBindingInEnd05.fs.opt.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ZeroToArrLength01.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ZeroToArrLength01.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ZeroToArrLength01.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ZeroToArrLength01.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ZeroToArrLength01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ZeroToArrLength01.fs.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ZeroToArrLength01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ZeroToArrLength01.fs.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ZeroToArrLength02.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ZeroToArrLength02.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ZeroToArrLength02.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ZeroToArrLength02.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ZeroToArrLength02.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ZeroToArrLength02.fs.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ZeroToArrLength02.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOff/ZeroToArrLength02.fs.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnArray01.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnArray01.fs
new file mode 100644
index 00000000000..ad9a9e104b5
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnArray01.fs
@@ -0,0 +1,8 @@
+// #Regression #CodeGen #Optimizations #ControlFlow #NoMono #ReqNOMT 
+// Regression test for FSHARP1.0:3982
+// Compiler should turn 'foreach' loops over arrays into 'for' loops
+module ForEachOnArray01
+let test3(arr: int[]) = 
+     let mutable z = 0
+     for x in arr do
+         z <- z + x
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnArray01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnArray01.fs.il.bsl
new file mode 100644
index 00000000000..9aa3224bb63
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnArray01.fs.il.bsl
@@ -0,0 +1,99 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  test3(int32[] arr) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.1
+    IL_0004:  br.s       IL_0016
+
+    IL_0006:  ldarg.0
+    IL_0007:  ldloc.1
+    IL_0008:  ldelem     [runtime]System.Int32
+    IL_000d:  stloc.2
+    IL_000e:  ldloc.0
+    IL_000f:  ldloc.2
+    IL_0010:  add
+    IL_0011:  stloc.0
+    IL_0012:  ldloc.1
+    IL_0013:  ldc.i4.1
+    IL_0014:  add
+    IL_0015:  stloc.1
+    IL_0016:  ldloc.1
+    IL_0017:  ldarg.0
+    IL_0018:  ldlen
+    IL_0019:  conv.i4
+    IL_001a:  blt.s      IL_0006
+
+    IL_001c:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnList01.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnList01.fs
new file mode 100644
index 00000000000..942d99c3234
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnList01.fs
@@ -0,0 +1,51 @@
+// #Regression #CodeGen #Optimizations #ControlFlow #NoMono #ReqNOMT
+// Compiler should turn 'foreach' loops over lists into 'while' loops
+module ForEachOnList01
+
+// Some variations to make sure optimizer can detect the foreach properly
+
+let test1(lst: int list) =
+     let mutable z = 0
+     for x in lst do
+         z <- z + x
+
+let test2() =
+     let mutable z = 0
+     for x in [1;2;3] do
+         z <- z + x
+
+let test3() =
+     let xs = [1;2;3]
+     let mutable z = 0
+     for x in xs do
+         z <- z + x
+
+let test4() =
+     let mutable z = 0
+     let xs = [1;2;3]
+     for x in xs do
+         z <- z + x
+
+let test5() =
+     let xs = [1;2;3]
+     for x in xs do
+         printfn "%A" x
+
+// more complex enumerable expression
+let test6() = 
+    for i in (
+                [1;2;3;4]
+                |> List.map (fun x ->
+                    x + 1)
+                ) do
+        printfn "%O" i
+ 
+// multiline body 
+let test7() = 
+    for i in (
+                [1;2;3;4]
+                |> List.map (fun x ->
+                    x + 1)
+                ) do
+        let tmp = i + 1
+        printfn "%O" tmp
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnList01.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnList01.fs.il.net472.debug.bsl
new file mode 100644
index 00000000000..9bd0a4ef373
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnList01.fs.il.net472.debug.bsl
@@ -0,0 +1,465 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit test6@38
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/test6@38 @_instance
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 
+            Invoke(int32 x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/test6@38::.ctor()
+      IL_0005:  stsfld     class assembly/test6@38 assembly/test6@38::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit test7@47
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/test7@47 @_instance
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 
+            Invoke(int32 x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/test7@47::.ctor()
+      IL_0005:  stsfld     class assembly/test7@47 assembly/test7@47::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .method public static void  test1(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> lst) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (int32 V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             int32 V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldarg.0
+    IL_0003:  stloc.1
+    IL_0004:  ldloc.1
+    IL_0005:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_000a:  stloc.2
+    IL_000b:  br.s       IL_0021
+
+    IL_000d:  ldloc.1
+    IL_000e:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0013:  stloc.3
+    IL_0014:  ldloc.0
+    IL_0015:  ldloc.3
+    IL_0016:  add
+    IL_0017:  stloc.0
+    IL_0018:  ldloc.2
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.1
+    IL_001b:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0020:  stloc.2
+    IL_0021:  ldloc.2
+    IL_0022:  brtrue.s   IL_000d
+
+    IL_0024:  ret
+  } 
+
+  .method public static void  test2() cil managed
+  {
+    
+    .maxstack  6
+    .locals init (int32 V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             int32 V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.2
+    IL_0004:  ldc.i4.3
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.1
+    IL_001b:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0020:  stloc.2
+    IL_0021:  br.s       IL_0037
+
+    IL_0023:  ldloc.1
+    IL_0024:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0029:  stloc.3
+    IL_002a:  ldloc.0
+    IL_002b:  ldloc.3
+    IL_002c:  add
+    IL_002d:  stloc.0
+    IL_002e:  ldloc.2
+    IL_002f:  stloc.1
+    IL_0030:  ldloc.1
+    IL_0031:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0036:  stloc.2
+    IL_0037:  ldloc.2
+    IL_0038:  brtrue.s   IL_0023
+
+    IL_003a:  ret
+  } 
+
+  .method public static void  test3() cil managed
+  {
+    
+    .maxstack  6
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             int32 V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_3,
+             int32 V_4)
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0008:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0017:  stloc.0
+    IL_0018:  ldc.i4.0
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.0
+    IL_001b:  stloc.2
+    IL_001c:  ldloc.2
+    IL_001d:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0022:  stloc.3
+    IL_0023:  br.s       IL_003b
+
+    IL_0025:  ldloc.2
+    IL_0026:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_002b:  stloc.s    V_4
+    IL_002d:  ldloc.1
+    IL_002e:  ldloc.s    V_4
+    IL_0030:  add
+    IL_0031:  stloc.1
+    IL_0032:  ldloc.3
+    IL_0033:  stloc.2
+    IL_0034:  ldloc.2
+    IL_0035:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_003a:  stloc.3
+    IL_003b:  ldloc.3
+    IL_003c:  brtrue.s   IL_0025
+
+    IL_003e:  ret
+  } 
+
+  .method public static void  test4() cil managed
+  {
+    
+    .maxstack  6
+    .locals init (int32 V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_3,
+             int32 V_4)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.2
+    IL_0004:  ldc.i4.3
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.1
+    IL_001b:  stloc.2
+    IL_001c:  ldloc.2
+    IL_001d:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0022:  stloc.3
+    IL_0023:  br.s       IL_003b
+
+    IL_0025:  ldloc.2
+    IL_0026:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_002b:  stloc.s    V_4
+    IL_002d:  ldloc.0
+    IL_002e:  ldloc.s    V_4
+    IL_0030:  add
+    IL_0031:  stloc.0
+    IL_0032:  ldloc.3
+    IL_0033:  stloc.2
+    IL_0034:  ldloc.2
+    IL_0035:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_003a:  stloc.3
+    IL_003b:  ldloc.3
+    IL_003c:  brtrue.s   IL_0025
+
+    IL_003e:  ret
+  } 
+
+  .method public static void  test5() cil managed
+  {
+    
+    .maxstack  6
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             int32 V_3)
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0008:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0017:  stloc.0
+    IL_0018:  ldloc.0
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.1
+    IL_001b:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0020:  stloc.2
+    IL_0021:  br.s       IL_0049
+
+    IL_0023:  ldloc.1
+    IL_0024:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0029:  stloc.3
+    IL_002a:  ldstr      "%A"
+    IL_002f:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_0034:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0039:  ldloc.3
+    IL_003a:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_003f:  pop
+    IL_0040:  ldloc.2
+    IL_0041:  stloc.1
+    IL_0042:  ldloc.1
+    IL_0043:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0048:  stloc.2
+    IL_0049:  ldloc.2
+    IL_004a:  brtrue.s   IL_0023
+
+    IL_004c:  ret
+  } 
+
+  .method public static void  test6() cil managed
+  {
+    
+    .maxstack  8
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2)
+    IL_0000:  ldsfld     class assembly/test6@38 assembly/test6@38::@_instance
+    IL_0005:  ldc.i4.1
+    IL_0006:  ldc.i4.2
+    IL_0007:  ldc.i4.3
+    IL_0008:  ldc.i4.4
+    IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0013:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0018:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0022:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::Map<int32,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0>)
+    IL_0027:  stloc.0
+    IL_0028:  ldloc.0
+    IL_0029:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_002e:  stloc.1
+    IL_002f:  br.s       IL_0057
+
+    IL_0031:  ldloc.0
+    IL_0032:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0037:  stloc.2
+    IL_0038:  ldstr      "%O"
+    IL_003d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_0042:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0047:  ldloc.2
+    IL_0048:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_004d:  pop
+    IL_004e:  ldloc.1
+    IL_004f:  stloc.0
+    IL_0050:  ldloc.0
+    IL_0051:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0056:  stloc.1
+    IL_0057:  ldloc.1
+    IL_0058:  brtrue.s   IL_0031
+
+    IL_005a:  ret
+  } 
+
+  .method public static void  test7() cil managed
+  {
+    
+    .maxstack  8
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2,
+             int32 V_3)
+    IL_0000:  ldsfld     class assembly/test7@47 assembly/test7@47::@_instance
+    IL_0005:  ldc.i4.1
+    IL_0006:  ldc.i4.2
+    IL_0007:  ldc.i4.3
+    IL_0008:  ldc.i4.4
+    IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0013:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0018:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0022:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::Map<int32,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0>)
+    IL_0027:  stloc.0
+    IL_0028:  ldloc.0
+    IL_0029:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_002e:  stloc.1
+    IL_002f:  br.s       IL_005b
+
+    IL_0031:  ldloc.0
+    IL_0032:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0037:  stloc.2
+    IL_0038:  ldloc.2
+    IL_0039:  ldc.i4.1
+    IL_003a:  add
+    IL_003b:  stloc.3
+    IL_003c:  ldstr      "%O"
+    IL_0041:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_0046:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_004b:  ldloc.3
+    IL_004c:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0051:  pop
+    IL_0052:  ldloc.1
+    IL_0053:  stloc.0
+    IL_0054:  ldloc.0
+    IL_0055:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_005a:  stloc.1
+    IL_005b:  ldloc.1
+    IL_005c:  brtrue.s   IL_0031
+
+    IL_005e:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnList01.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnList01.fs.il.net472.release.bsl
new file mode 100644
index 00000000000..626c68acbf7
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnList01.fs.il.net472.release.bsl
@@ -0,0 +1,485 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit test6@38
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/test6@38 @_instance
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 
+            Invoke(int32 x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/test6@38::.ctor()
+      IL_0005:  stsfld     class assembly/test6@38 assembly/test6@38::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit test7@47
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/test7@47 @_instance
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 
+            Invoke(int32 x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/test7@47::.ctor()
+      IL_0005:  stsfld     class assembly/test7@47 assembly/test7@47::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .method public static void  test1(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> lst) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (int32 V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             int32 V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldarg.0
+    IL_0003:  stloc.1
+    IL_0004:  ldloc.1
+    IL_0005:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_000a:  stloc.2
+    IL_000b:  br.s       IL_0021
+
+    IL_000d:  ldloc.1
+    IL_000e:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0013:  stloc.3
+    IL_0014:  ldloc.0
+    IL_0015:  ldloc.3
+    IL_0016:  add
+    IL_0017:  stloc.0
+    IL_0018:  ldloc.2
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.1
+    IL_001b:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0020:  stloc.2
+    IL_0021:  ldloc.2
+    IL_0022:  brtrue.s   IL_000d
+
+    IL_0024:  ret
+  } 
+
+  .method public static void  test2() cil managed
+  {
+    
+    .maxstack  6
+    .locals init (int32 V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             int32 V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.2
+    IL_0004:  ldc.i4.3
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.1
+    IL_001b:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0020:  stloc.2
+    IL_0021:  br.s       IL_0037
+
+    IL_0023:  ldloc.1
+    IL_0024:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0029:  stloc.3
+    IL_002a:  ldloc.0
+    IL_002b:  ldloc.3
+    IL_002c:  add
+    IL_002d:  stloc.0
+    IL_002e:  ldloc.2
+    IL_002f:  stloc.1
+    IL_0030:  ldloc.1
+    IL_0031:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0036:  stloc.2
+    IL_0037:  ldloc.2
+    IL_0038:  brtrue.s   IL_0023
+
+    IL_003a:  ret
+  } 
+
+  .method public static void  test3() cil managed
+  {
+    
+    .maxstack  6
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             int32 V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_3,
+             int32 V_4)
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0008:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0017:  stloc.0
+    IL_0018:  ldc.i4.0
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.0
+    IL_001b:  stloc.2
+    IL_001c:  ldloc.2
+    IL_001d:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0022:  stloc.3
+    IL_0023:  br.s       IL_003b
+
+    IL_0025:  ldloc.2
+    IL_0026:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_002b:  stloc.s    V_4
+    IL_002d:  ldloc.1
+    IL_002e:  ldloc.s    V_4
+    IL_0030:  add
+    IL_0031:  stloc.1
+    IL_0032:  ldloc.3
+    IL_0033:  stloc.2
+    IL_0034:  ldloc.2
+    IL_0035:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_003a:  stloc.3
+    IL_003b:  ldloc.3
+    IL_003c:  brtrue.s   IL_0025
+
+    IL_003e:  ret
+  } 
+
+  .method public static void  test4() cil managed
+  {
+    
+    .maxstack  6
+    .locals init (int32 V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_3,
+             int32 V_4)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.2
+    IL_0004:  ldc.i4.3
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.1
+    IL_001b:  stloc.2
+    IL_001c:  ldloc.2
+    IL_001d:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0022:  stloc.3
+    IL_0023:  br.s       IL_003b
+
+    IL_0025:  ldloc.2
+    IL_0026:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_002b:  stloc.s    V_4
+    IL_002d:  ldloc.0
+    IL_002e:  ldloc.s    V_4
+    IL_0030:  add
+    IL_0031:  stloc.0
+    IL_0032:  ldloc.3
+    IL_0033:  stloc.2
+    IL_0034:  ldloc.2
+    IL_0035:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_003a:  stloc.3
+    IL_003b:  ldloc.3
+    IL_003c:  brtrue.s   IL_0025
+
+    IL_003e:  ret
+  } 
+
+  .method public static void  test5() cil managed
+  {
+    
+    .maxstack  6
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             int32 V_3,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_4)
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0008:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0017:  stloc.0
+    IL_0018:  ldloc.0
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.1
+    IL_001b:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0020:  stloc.2
+    IL_0021:  br.s       IL_0052
+
+    IL_0023:  ldloc.1
+    IL_0024:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0029:  stloc.3
+    IL_002a:  ldstr      "%A"
+    IL_002f:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_0034:  stloc.s    V_4
+    IL_0036:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_003b:  ldloc.s    V_4
+    IL_003d:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0042:  ldloc.3
+    IL_0043:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0048:  pop
+    IL_0049:  ldloc.2
+    IL_004a:  stloc.1
+    IL_004b:  ldloc.1
+    IL_004c:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0051:  stloc.2
+    IL_0052:  ldloc.2
+    IL_0053:  brtrue.s   IL_0023
+
+    IL_0055:  ret
+  } 
+
+  .method public static void  test6() cil managed
+  {
+    
+    .maxstack  8
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_3)
+    IL_0000:  ldsfld     class assembly/test6@38 assembly/test6@38::@_instance
+    IL_0005:  ldc.i4.1
+    IL_0006:  ldc.i4.2
+    IL_0007:  ldc.i4.3
+    IL_0008:  ldc.i4.4
+    IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0013:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0018:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0022:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::Map<int32,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0>)
+    IL_0027:  stloc.0
+    IL_0028:  ldloc.0
+    IL_0029:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_002e:  stloc.1
+    IL_002f:  br.s       IL_005e
+
+    IL_0031:  ldloc.0
+    IL_0032:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0037:  stloc.2
+    IL_0038:  ldstr      "%O"
+    IL_003d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_0042:  stloc.3
+    IL_0043:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_0048:  ldloc.3
+    IL_0049:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_004e:  ldloc.2
+    IL_004f:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0054:  pop
+    IL_0055:  ldloc.1
+    IL_0056:  stloc.0
+    IL_0057:  ldloc.0
+    IL_0058:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_005d:  stloc.1
+    IL_005e:  ldloc.1
+    IL_005f:  brtrue.s   IL_0031
+
+    IL_0061:  ret
+  } 
+
+  .method public static void  test7() cil managed
+  {
+    
+    .maxstack  8
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2,
+             int32 V_3,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_4)
+    IL_0000:  ldsfld     class assembly/test7@47 assembly/test7@47::@_instance
+    IL_0005:  ldc.i4.1
+    IL_0006:  ldc.i4.2
+    IL_0007:  ldc.i4.3
+    IL_0008:  ldc.i4.4
+    IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0013:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0018:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0022:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::Map<int32,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0>)
+    IL_0027:  stloc.0
+    IL_0028:  ldloc.0
+    IL_0029:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_002e:  stloc.1
+    IL_002f:  br.s       IL_0064
+
+    IL_0031:  ldloc.0
+    IL_0032:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0037:  stloc.2
+    IL_0038:  ldloc.2
+    IL_0039:  ldc.i4.1
+    IL_003a:  add
+    IL_003b:  stloc.3
+    IL_003c:  ldstr      "%O"
+    IL_0041:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_0046:  stloc.s    V_4
+    IL_0048:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_004d:  ldloc.s    V_4
+    IL_004f:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0054:  ldloc.3
+    IL_0055:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_005a:  pop
+    IL_005b:  ldloc.1
+    IL_005c:  stloc.0
+    IL_005d:  ldloc.0
+    IL_005e:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0063:  stloc.1
+    IL_0064:  ldloc.1
+    IL_0065:  brtrue.s   IL_0031
+
+    IL_0067:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnList01.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnList01.fs.il.netcore.debug.bsl
new file mode 100644
index 00000000000..9bd0a4ef373
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnList01.fs.il.netcore.debug.bsl
@@ -0,0 +1,465 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit test6@38
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/test6@38 @_instance
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 
+            Invoke(int32 x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/test6@38::.ctor()
+      IL_0005:  stsfld     class assembly/test6@38 assembly/test6@38::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit test7@47
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/test7@47 @_instance
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 
+            Invoke(int32 x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/test7@47::.ctor()
+      IL_0005:  stsfld     class assembly/test7@47 assembly/test7@47::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .method public static void  test1(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> lst) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (int32 V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             int32 V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldarg.0
+    IL_0003:  stloc.1
+    IL_0004:  ldloc.1
+    IL_0005:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_000a:  stloc.2
+    IL_000b:  br.s       IL_0021
+
+    IL_000d:  ldloc.1
+    IL_000e:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0013:  stloc.3
+    IL_0014:  ldloc.0
+    IL_0015:  ldloc.3
+    IL_0016:  add
+    IL_0017:  stloc.0
+    IL_0018:  ldloc.2
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.1
+    IL_001b:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0020:  stloc.2
+    IL_0021:  ldloc.2
+    IL_0022:  brtrue.s   IL_000d
+
+    IL_0024:  ret
+  } 
+
+  .method public static void  test2() cil managed
+  {
+    
+    .maxstack  6
+    .locals init (int32 V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             int32 V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.2
+    IL_0004:  ldc.i4.3
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.1
+    IL_001b:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0020:  stloc.2
+    IL_0021:  br.s       IL_0037
+
+    IL_0023:  ldloc.1
+    IL_0024:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0029:  stloc.3
+    IL_002a:  ldloc.0
+    IL_002b:  ldloc.3
+    IL_002c:  add
+    IL_002d:  stloc.0
+    IL_002e:  ldloc.2
+    IL_002f:  stloc.1
+    IL_0030:  ldloc.1
+    IL_0031:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0036:  stloc.2
+    IL_0037:  ldloc.2
+    IL_0038:  brtrue.s   IL_0023
+
+    IL_003a:  ret
+  } 
+
+  .method public static void  test3() cil managed
+  {
+    
+    .maxstack  6
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             int32 V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_3,
+             int32 V_4)
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0008:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0017:  stloc.0
+    IL_0018:  ldc.i4.0
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.0
+    IL_001b:  stloc.2
+    IL_001c:  ldloc.2
+    IL_001d:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0022:  stloc.3
+    IL_0023:  br.s       IL_003b
+
+    IL_0025:  ldloc.2
+    IL_0026:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_002b:  stloc.s    V_4
+    IL_002d:  ldloc.1
+    IL_002e:  ldloc.s    V_4
+    IL_0030:  add
+    IL_0031:  stloc.1
+    IL_0032:  ldloc.3
+    IL_0033:  stloc.2
+    IL_0034:  ldloc.2
+    IL_0035:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_003a:  stloc.3
+    IL_003b:  ldloc.3
+    IL_003c:  brtrue.s   IL_0025
+
+    IL_003e:  ret
+  } 
+
+  .method public static void  test4() cil managed
+  {
+    
+    .maxstack  6
+    .locals init (int32 V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_3,
+             int32 V_4)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.2
+    IL_0004:  ldc.i4.3
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.1
+    IL_001b:  stloc.2
+    IL_001c:  ldloc.2
+    IL_001d:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0022:  stloc.3
+    IL_0023:  br.s       IL_003b
+
+    IL_0025:  ldloc.2
+    IL_0026:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_002b:  stloc.s    V_4
+    IL_002d:  ldloc.0
+    IL_002e:  ldloc.s    V_4
+    IL_0030:  add
+    IL_0031:  stloc.0
+    IL_0032:  ldloc.3
+    IL_0033:  stloc.2
+    IL_0034:  ldloc.2
+    IL_0035:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_003a:  stloc.3
+    IL_003b:  ldloc.3
+    IL_003c:  brtrue.s   IL_0025
+
+    IL_003e:  ret
+  } 
+
+  .method public static void  test5() cil managed
+  {
+    
+    .maxstack  6
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             int32 V_3)
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0008:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0017:  stloc.0
+    IL_0018:  ldloc.0
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.1
+    IL_001b:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0020:  stloc.2
+    IL_0021:  br.s       IL_0049
+
+    IL_0023:  ldloc.1
+    IL_0024:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0029:  stloc.3
+    IL_002a:  ldstr      "%A"
+    IL_002f:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_0034:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0039:  ldloc.3
+    IL_003a:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_003f:  pop
+    IL_0040:  ldloc.2
+    IL_0041:  stloc.1
+    IL_0042:  ldloc.1
+    IL_0043:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0048:  stloc.2
+    IL_0049:  ldloc.2
+    IL_004a:  brtrue.s   IL_0023
+
+    IL_004c:  ret
+  } 
+
+  .method public static void  test6() cil managed
+  {
+    
+    .maxstack  8
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2)
+    IL_0000:  ldsfld     class assembly/test6@38 assembly/test6@38::@_instance
+    IL_0005:  ldc.i4.1
+    IL_0006:  ldc.i4.2
+    IL_0007:  ldc.i4.3
+    IL_0008:  ldc.i4.4
+    IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0013:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0018:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0022:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::Map<int32,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0>)
+    IL_0027:  stloc.0
+    IL_0028:  ldloc.0
+    IL_0029:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_002e:  stloc.1
+    IL_002f:  br.s       IL_0057
+
+    IL_0031:  ldloc.0
+    IL_0032:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0037:  stloc.2
+    IL_0038:  ldstr      "%O"
+    IL_003d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_0042:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0047:  ldloc.2
+    IL_0048:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_004d:  pop
+    IL_004e:  ldloc.1
+    IL_004f:  stloc.0
+    IL_0050:  ldloc.0
+    IL_0051:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0056:  stloc.1
+    IL_0057:  ldloc.1
+    IL_0058:  brtrue.s   IL_0031
+
+    IL_005a:  ret
+  } 
+
+  .method public static void  test7() cil managed
+  {
+    
+    .maxstack  8
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2,
+             int32 V_3)
+    IL_0000:  ldsfld     class assembly/test7@47 assembly/test7@47::@_instance
+    IL_0005:  ldc.i4.1
+    IL_0006:  ldc.i4.2
+    IL_0007:  ldc.i4.3
+    IL_0008:  ldc.i4.4
+    IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0013:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0018:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0022:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::Map<int32,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0>)
+    IL_0027:  stloc.0
+    IL_0028:  ldloc.0
+    IL_0029:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_002e:  stloc.1
+    IL_002f:  br.s       IL_005b
+
+    IL_0031:  ldloc.0
+    IL_0032:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0037:  stloc.2
+    IL_0038:  ldloc.2
+    IL_0039:  ldc.i4.1
+    IL_003a:  add
+    IL_003b:  stloc.3
+    IL_003c:  ldstr      "%O"
+    IL_0041:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_0046:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_004b:  ldloc.3
+    IL_004c:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0051:  pop
+    IL_0052:  ldloc.1
+    IL_0053:  stloc.0
+    IL_0054:  ldloc.0
+    IL_0055:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_005a:  stloc.1
+    IL_005b:  ldloc.1
+    IL_005c:  brtrue.s   IL_0031
+
+    IL_005e:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnList01.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnList01.fs.il.netcore.release.bsl
new file mode 100644
index 00000000000..ffb525ce929
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnList01.fs.il.netcore.release.bsl
@@ -0,0 +1,485 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit test6@38
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/test6@38 @_instance
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 
+            Invoke(int32 x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/test6@38::.ctor()
+      IL_0005:  stsfld     class assembly/test6@38 assembly/test6@38::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit test7@47
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/test7@47 @_instance
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 
+            Invoke(int32 x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/test7@47::.ctor()
+      IL_0005:  stsfld     class assembly/test7@47 assembly/test7@47::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .method public static void  test1(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> lst) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (int32 V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             int32 V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldarg.0
+    IL_0003:  stloc.1
+    IL_0004:  ldloc.1
+    IL_0005:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_000a:  stloc.2
+    IL_000b:  br.s       IL_0021
+
+    IL_000d:  ldloc.1
+    IL_000e:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0013:  stloc.3
+    IL_0014:  ldloc.0
+    IL_0015:  ldloc.3
+    IL_0016:  add
+    IL_0017:  stloc.0
+    IL_0018:  ldloc.2
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.1
+    IL_001b:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0020:  stloc.2
+    IL_0021:  ldloc.2
+    IL_0022:  brtrue.s   IL_000d
+
+    IL_0024:  ret
+  } 
+
+  .method public static void  test2() cil managed
+  {
+    
+    .maxstack  6
+    .locals init (int32 V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             int32 V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.2
+    IL_0004:  ldc.i4.3
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.1
+    IL_001b:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0020:  stloc.2
+    IL_0021:  br.s       IL_0037
+
+    IL_0023:  ldloc.1
+    IL_0024:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0029:  stloc.3
+    IL_002a:  ldloc.0
+    IL_002b:  ldloc.3
+    IL_002c:  add
+    IL_002d:  stloc.0
+    IL_002e:  ldloc.2
+    IL_002f:  stloc.1
+    IL_0030:  ldloc.1
+    IL_0031:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0036:  stloc.2
+    IL_0037:  ldloc.2
+    IL_0038:  brtrue.s   IL_0023
+
+    IL_003a:  ret
+  } 
+
+  .method public static void  test3() cil managed
+  {
+    
+    .maxstack  6
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             int32 V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_3,
+             int32 V_4)
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0008:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0017:  stloc.0
+    IL_0018:  ldc.i4.0
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.0
+    IL_001b:  stloc.2
+    IL_001c:  ldloc.2
+    IL_001d:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0022:  stloc.3
+    IL_0023:  br.s       IL_003b
+
+    IL_0025:  ldloc.2
+    IL_0026:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_002b:  stloc.s    V_4
+    IL_002d:  ldloc.1
+    IL_002e:  ldloc.s    V_4
+    IL_0030:  add
+    IL_0031:  stloc.1
+    IL_0032:  ldloc.3
+    IL_0033:  stloc.2
+    IL_0034:  ldloc.2
+    IL_0035:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_003a:  stloc.3
+    IL_003b:  ldloc.3
+    IL_003c:  brtrue.s   IL_0025
+
+    IL_003e:  ret
+  } 
+
+  .method public static void  test4() cil managed
+  {
+    
+    .maxstack  6
+    .locals init (int32 V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_3,
+             int32 V_4)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.2
+    IL_0004:  ldc.i4.3
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.1
+    IL_001b:  stloc.2
+    IL_001c:  ldloc.2
+    IL_001d:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0022:  stloc.3
+    IL_0023:  br.s       IL_003b
+
+    IL_0025:  ldloc.2
+    IL_0026:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_002b:  stloc.s    V_4
+    IL_002d:  ldloc.0
+    IL_002e:  ldloc.s    V_4
+    IL_0030:  add
+    IL_0031:  stloc.0
+    IL_0032:  ldloc.3
+    IL_0033:  stloc.2
+    IL_0034:  ldloc.2
+    IL_0035:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_003a:  stloc.3
+    IL_003b:  ldloc.3
+    IL_003c:  brtrue.s   IL_0025
+
+    IL_003e:  ret
+  } 
+
+  .method public static void  test5() cil managed
+  {
+    
+    .maxstack  6
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+             int32 V_3,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_4)
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0008:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0017:  stloc.0
+    IL_0018:  ldloc.0
+    IL_0019:  stloc.1
+    IL_001a:  ldloc.1
+    IL_001b:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0020:  stloc.2
+    IL_0021:  br.s       IL_0052
+
+    IL_0023:  ldloc.1
+    IL_0024:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0029:  stloc.3
+    IL_002a:  ldstr      "%A"
+    IL_002f:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_0034:  stloc.s    V_4
+    IL_0036:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_003b:  ldloc.s    V_4
+    IL_003d:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0042:  ldloc.3
+    IL_0043:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0048:  pop
+    IL_0049:  ldloc.2
+    IL_004a:  stloc.1
+    IL_004b:  ldloc.1
+    IL_004c:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0051:  stloc.2
+    IL_0052:  ldloc.2
+    IL_0053:  brtrue.s   IL_0023
+
+    IL_0055:  ret
+  } 
+
+  .method public static void  test6() cil managed
+  {
+    
+    .maxstack  8
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_3)
+    IL_0000:  ldsfld     class assembly/test6@38 assembly/test6@38::@_instance
+    IL_0005:  ldc.i4.1
+    IL_0006:  ldc.i4.2
+    IL_0007:  ldc.i4.3
+    IL_0008:  ldc.i4.4
+    IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0013:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0018:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0022:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::Map<int32,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0>)
+    IL_0027:  stloc.0
+    IL_0028:  ldloc.0
+    IL_0029:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_002e:  stloc.1
+    IL_002f:  br.s       IL_005e
+
+    IL_0031:  ldloc.0
+    IL_0032:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0037:  stloc.2
+    IL_0038:  ldstr      "%O"
+    IL_003d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_0042:  stloc.3
+    IL_0043:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_0048:  ldloc.3
+    IL_0049:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_004e:  ldloc.2
+    IL_004f:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0054:  pop
+    IL_0055:  ldloc.1
+    IL_0056:  stloc.0
+    IL_0057:  ldloc.0
+    IL_0058:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_005d:  stloc.1
+    IL_005e:  ldloc.1
+    IL_005f:  brtrue.s   IL_0031
+
+    IL_0061:  ret
+  } 
+
+  .method public static void  test7() cil managed
+  {
+    
+    .maxstack  8
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2,
+             int32 V_3,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_4)
+    IL_0000:  ldsfld     class assembly/test7@47 assembly/test7@47::@_instance
+    IL_0005:  ldc.i4.1
+    IL_0006:  ldc.i4.2
+    IL_0007:  ldc.i4.3
+    IL_0008:  ldc.i4.4
+    IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0013:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0018:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0022:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::Map<int32,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0>)
+    IL_0027:  stloc.0
+    IL_0028:  ldloc.0
+    IL_0029:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_002e:  stloc.1
+    IL_002f:  br.s       IL_0064
+
+    IL_0031:  ldloc.0
+    IL_0032:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0037:  stloc.2
+    IL_0038:  ldloc.2
+    IL_0039:  ldc.i4.1
+    IL_003a:  add
+    IL_003b:  stloc.3
+    IL_003c:  ldstr      "%O"
+    IL_0041:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_0046:  stloc.s    V_4
+    IL_0048:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_004d:  ldloc.s    V_4
+    IL_004f:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0054:  ldloc.3
+    IL_0055:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_005a:  pop
+    IL_005b:  ldloc.1
+    IL_005c:  stloc.0
+    IL_005d:  ldloc.0
+    IL_005e:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0063:  stloc.1
+    IL_0064:  ldloc.1
+    IL_0065:  brtrue.s   IL_0031
+
+    IL_0067:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnString01.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnString01.fs
new file mode 100644
index 00000000000..04262a04e63
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnString01.fs
@@ -0,0 +1,67 @@
+// #Regression #CodeGen #Optimizations #ControlFlow #NoMono #ReqNOMT
+// Compiler should turn 'foreach' loops over strings into 'for' loops
+module ForEachOnString01
+
+open System
+
+let test1(str: string) =
+     let mutable z = 0
+     for x in str do
+         z <- z + (int x)
+
+let test2() =
+     let mutable z = 0
+     for x in "123" do
+         z <- z + (int x)
+
+let test3() =
+     let xs = "123"
+     let mutable z = 0
+     for x in xs do
+         z <- z + (int x)
+
+let test4() =
+     let mutable z = 0
+     let xs = "123"
+     for x in xs do
+         z <- z + (int x)
+
+let test5() =
+     let xs = "123"
+     for x in xs do
+         printfn "%A" x
+
+// test6, test7 makes sure the optimization triggers
+// for System.String and String as well.
+// They are the same type as string but internally string
+// is an alias which potentially could make the optimizer
+// miss one case or the other
+let test6(str: System.String) =
+     let mutable z = 0
+     for x in str do
+         z <- z + (int x)
+
+let test7() =
+     let xs : String = "123"
+     let mutable z = 0
+     for x in xs do
+         z <- z + (int x)
+
+// more complex enumerable expression
+let test8() =
+    for i in (
+                "1234"
+                |> String.map (fun x ->
+                    char ((int x) + 1))
+                ) do
+        printfn "%O" i
+
+// multiline body
+let test9() =
+    for i in (
+                "1234"
+                |> String.map (fun x ->
+                    char ((int x) + 1))
+                ) do
+        let tmp = System.String.Format("{0} foo", i)
+        printfn "%O" tmp
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnString01.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnString01.fs.il.net472.debug.bsl
new file mode 100644
index 00000000000..e0dc7ca6f63
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnString01.fs.il.net472.debug.bsl
@@ -0,0 +1,556 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit test8@54
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>
+  {
+    .field static assembly initonly class assembly/test8@54 @_instance
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance char 
+            Invoke(char x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  conv.i4
+      IL_0002:  ldc.i4.1
+      IL_0003:  add
+      IL_0004:  conv.u2
+      IL_0005:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/test8@54::.ctor()
+      IL_0005:  stsfld     class assembly/test8@54 assembly/test8@54::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit test9@63
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>
+  {
+    .field static assembly initonly class assembly/test9@63 @_instance
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance char 
+            Invoke(char x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  conv.i4
+      IL_0002:  ldc.i4.1
+      IL_0003:  add
+      IL_0004:  conv.u2
+      IL_0005:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/test9@63::.ctor()
+      IL_0005:  stsfld     class assembly/test9@63 assembly/test9@63::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .method public static void  test1(string str) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.2
+    IL_0004:  ldarg.0
+    IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000a:  ldc.i4.1
+    IL_000b:  sub
+    IL_000c:  stloc.1
+    IL_000d:  ldloc.1
+    IL_000e:  ldloc.2
+    IL_000f:  blt.s      IL_0028
+
+    IL_0011:  ldarg.0
+    IL_0012:  ldloc.2
+    IL_0013:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.0
+    IL_001a:  ldloc.3
+    IL_001b:  conv.i4
+    IL_001c:  add
+    IL_001d:  stloc.0
+    IL_001e:  ldloc.2
+    IL_001f:  ldc.i4.1
+    IL_0020:  add
+    IL_0021:  stloc.2
+    IL_0022:  ldloc.2
+    IL_0023:  ldloc.1
+    IL_0024:  ldc.i4.1
+    IL_0025:  add
+    IL_0026:  bne.un.s   IL_0011
+
+    IL_0028:  ret
+  } 
+
+  .method public static void  test2() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.2
+    IL_0004:  ldstr      "123"
+    IL_0009:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000e:  ldc.i4.1
+    IL_000f:  sub
+    IL_0010:  stloc.1
+    IL_0011:  ldloc.1
+    IL_0012:  ldloc.2
+    IL_0013:  blt.s      IL_0030
+
+    IL_0015:  ldstr      "123"
+    IL_001a:  ldloc.2
+    IL_001b:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0020:  stloc.3
+    IL_0021:  ldloc.0
+    IL_0022:  ldloc.3
+    IL_0023:  conv.i4
+    IL_0024:  add
+    IL_0025:  stloc.0
+    IL_0026:  ldloc.2
+    IL_0027:  ldc.i4.1
+    IL_0028:  add
+    IL_0029:  stloc.2
+    IL_002a:  ldloc.2
+    IL_002b:  ldloc.1
+    IL_002c:  ldc.i4.1
+    IL_002d:  add
+    IL_002e:  bne.un.s   IL_0015
+
+    IL_0030:  ret
+  } 
+
+  .method public static void  test3() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  stloc.0
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.2
+    IL_0005:  ldstr      "123"
+    IL_000a:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000f:  ldc.i4.1
+    IL_0010:  sub
+    IL_0011:  stloc.1
+    IL_0012:  ldloc.1
+    IL_0013:  ldloc.2
+    IL_0014:  blt.s      IL_0031
+
+    IL_0016:  ldstr      "123"
+    IL_001b:  ldloc.2
+    IL_001c:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0021:  stloc.3
+    IL_0022:  ldloc.0
+    IL_0023:  ldloc.3
+    IL_0024:  conv.i4
+    IL_0025:  add
+    IL_0026:  stloc.0
+    IL_0027:  ldloc.2
+    IL_0028:  ldc.i4.1
+    IL_0029:  add
+    IL_002a:  stloc.2
+    IL_002b:  ldloc.2
+    IL_002c:  ldloc.1
+    IL_002d:  ldc.i4.1
+    IL_002e:  add
+    IL_002f:  bne.un.s   IL_0016
+
+    IL_0031:  ret
+  } 
+
+  .method public static void  test4() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  nop
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.2
+    IL_0005:  ldstr      "123"
+    IL_000a:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000f:  ldc.i4.1
+    IL_0010:  sub
+    IL_0011:  stloc.1
+    IL_0012:  ldloc.1
+    IL_0013:  ldloc.2
+    IL_0014:  blt.s      IL_0031
+
+    IL_0016:  ldstr      "123"
+    IL_001b:  ldloc.2
+    IL_001c:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0021:  stloc.3
+    IL_0022:  ldloc.0
+    IL_0023:  ldloc.3
+    IL_0024:  conv.i4
+    IL_0025:  add
+    IL_0026:  stloc.0
+    IL_0027:  ldloc.2
+    IL_0028:  ldc.i4.1
+    IL_0029:  add
+    IL_002a:  stloc.2
+    IL_002b:  ldloc.2
+    IL_002c:  ldloc.1
+    IL_002d:  ldc.i4.1
+    IL_002e:  add
+    IL_002f:  bne.un.s   IL_0016
+
+    IL_0031:  ret
+  } 
+
+  .method public static void  test5() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             char V_2)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  stloc.1
+    IL_0003:  ldstr      "123"
+    IL_0008:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000d:  ldc.i4.1
+    IL_000e:  sub
+    IL_000f:  stloc.0
+    IL_0010:  ldloc.0
+    IL_0011:  ldloc.1
+    IL_0012:  blt.s      IL_0040
+
+    IL_0014:  ldstr      "123"
+    IL_0019:  ldloc.1
+    IL_001a:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_001f:  stloc.2
+    IL_0020:  ldstr      "%A"
+    IL_0025:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,char>::.ctor(string)
+    IL_002a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_002f:  ldloc.2
+    IL_0030:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0035:  pop
+    IL_0036:  ldloc.1
+    IL_0037:  ldc.i4.1
+    IL_0038:  add
+    IL_0039:  stloc.1
+    IL_003a:  ldloc.1
+    IL_003b:  ldloc.0
+    IL_003c:  ldc.i4.1
+    IL_003d:  add
+    IL_003e:  bne.un.s   IL_0014
+
+    IL_0040:  ret
+  } 
+
+  .method public static void  test6(string str) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.2
+    IL_0004:  ldarg.0
+    IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000a:  ldc.i4.1
+    IL_000b:  sub
+    IL_000c:  stloc.1
+    IL_000d:  ldloc.1
+    IL_000e:  ldloc.2
+    IL_000f:  blt.s      IL_0028
+
+    IL_0011:  ldarg.0
+    IL_0012:  ldloc.2
+    IL_0013:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.0
+    IL_001a:  ldloc.3
+    IL_001b:  conv.i4
+    IL_001c:  add
+    IL_001d:  stloc.0
+    IL_001e:  ldloc.2
+    IL_001f:  ldc.i4.1
+    IL_0020:  add
+    IL_0021:  stloc.2
+    IL_0022:  ldloc.2
+    IL_0023:  ldloc.1
+    IL_0024:  ldc.i4.1
+    IL_0025:  add
+    IL_0026:  bne.un.s   IL_0011
+
+    IL_0028:  ret
+  } 
+
+  .method public static void  test7() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  stloc.0
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.2
+    IL_0005:  ldstr      "123"
+    IL_000a:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000f:  ldc.i4.1
+    IL_0010:  sub
+    IL_0011:  stloc.1
+    IL_0012:  ldloc.1
+    IL_0013:  ldloc.2
+    IL_0014:  blt.s      IL_0031
+
+    IL_0016:  ldstr      "123"
+    IL_001b:  ldloc.2
+    IL_001c:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0021:  stloc.3
+    IL_0022:  ldloc.0
+    IL_0023:  ldloc.3
+    IL_0024:  conv.i4
+    IL_0025:  add
+    IL_0026:  stloc.0
+    IL_0027:  ldloc.2
+    IL_0028:  ldc.i4.1
+    IL_0029:  add
+    IL_002a:  stloc.2
+    IL_002b:  ldloc.2
+    IL_002c:  ldloc.1
+    IL_002d:  ldc.i4.1
+    IL_002e:  add
+    IL_002f:  bne.un.s   IL_0016
+
+    IL_0031:  ret
+  } 
+
+  .method public static void  test8() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (string V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldsfld     class assembly/test8@54 assembly/test8@54::@_instance
+    IL_0005:  ldstr      "1234"
+    IL_000a:  call       string [FSharp.Core]Microsoft.FSharp.Core.StringModule::Map(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>,
+                                                                                     string)
+    IL_000f:  stloc.0
+    IL_0010:  ldc.i4.0
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.0
+    IL_0013:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_0018:  ldc.i4.1
+    IL_0019:  sub
+    IL_001a:  stloc.1
+    IL_001b:  ldloc.1
+    IL_001c:  ldloc.2
+    IL_001d:  blt.s      IL_0047
+
+    IL_001f:  ldloc.0
+    IL_0020:  ldloc.2
+    IL_0021:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0026:  stloc.3
+    IL_0027:  ldstr      "%O"
+    IL_002c:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,char>::.ctor(string)
+    IL_0031:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0036:  ldloc.3
+    IL_0037:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_003c:  pop
+    IL_003d:  ldloc.2
+    IL_003e:  ldc.i4.1
+    IL_003f:  add
+    IL_0040:  stloc.2
+    IL_0041:  ldloc.2
+    IL_0042:  ldloc.1
+    IL_0043:  ldc.i4.1
+    IL_0044:  add
+    IL_0045:  bne.un.s   IL_001f
+
+    IL_0047:  ret
+  } 
+
+  .method public static void  test9() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (string V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3,
+             string V_4)
+    IL_0000:  ldsfld     class assembly/test9@63 assembly/test9@63::@_instance
+    IL_0005:  ldstr      "1234"
+    IL_000a:  call       string [FSharp.Core]Microsoft.FSharp.Core.StringModule::Map(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>,
+                                                                                     string)
+    IL_000f:  stloc.0
+    IL_0010:  ldc.i4.0
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.0
+    IL_0013:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_0018:  ldc.i4.1
+    IL_0019:  sub
+    IL_001a:  stloc.1
+    IL_001b:  ldloc.1
+    IL_001c:  ldloc.2
+    IL_001d:  blt.s      IL_005a
+
+    IL_001f:  ldloc.0
+    IL_0020:  ldloc.2
+    IL_0021:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0026:  stloc.3
+    IL_0027:  ldstr      "{0} foo"
+    IL_002c:  ldloc.3
+    IL_002d:  box        [runtime]System.Char
+    IL_0032:  call       string [runtime]System.String::Format(string,
+                                                                object)
+    IL_0037:  stloc.s    V_4
+    IL_0039:  ldstr      "%O"
+    IL_003e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string>::.ctor(string)
+    IL_0043:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0048:  ldloc.s    V_4
+    IL_004a:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_004f:  pop
+    IL_0050:  ldloc.2
+    IL_0051:  ldc.i4.1
+    IL_0052:  add
+    IL_0053:  stloc.2
+    IL_0054:  ldloc.2
+    IL_0055:  ldloc.1
+    IL_0056:  ldc.i4.1
+    IL_0057:  add
+    IL_0058:  bne.un.s   IL_001f
+
+    IL_005a:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnString01.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnString01.fs.il.net472.release.bsl
new file mode 100644
index 00000000000..438815ac15a
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnString01.fs.il.net472.release.bsl
@@ -0,0 +1,571 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit test8@54
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>
+  {
+    .field static assembly initonly class assembly/test8@54 @_instance
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance char 
+            Invoke(char x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  conv.i4
+      IL_0002:  ldc.i4.1
+      IL_0003:  add
+      IL_0004:  conv.u2
+      IL_0005:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/test8@54::.ctor()
+      IL_0005:  stsfld     class assembly/test8@54 assembly/test8@54::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit test9@63
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>
+  {
+    .field static assembly initonly class assembly/test9@63 @_instance
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance char 
+            Invoke(char x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  conv.i4
+      IL_0002:  ldc.i4.1
+      IL_0003:  add
+      IL_0004:  conv.u2
+      IL_0005:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/test9@63::.ctor()
+      IL_0005:  stsfld     class assembly/test9@63 assembly/test9@63::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .method public static void  test1(string str) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.2
+    IL_0004:  ldarg.0
+    IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000a:  ldc.i4.1
+    IL_000b:  sub
+    IL_000c:  stloc.1
+    IL_000d:  ldloc.1
+    IL_000e:  ldloc.2
+    IL_000f:  blt.s      IL_0028
+
+    IL_0011:  ldarg.0
+    IL_0012:  ldloc.2
+    IL_0013:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.0
+    IL_001a:  ldloc.3
+    IL_001b:  conv.i4
+    IL_001c:  add
+    IL_001d:  stloc.0
+    IL_001e:  ldloc.2
+    IL_001f:  ldc.i4.1
+    IL_0020:  add
+    IL_0021:  stloc.2
+    IL_0022:  ldloc.2
+    IL_0023:  ldloc.1
+    IL_0024:  ldc.i4.1
+    IL_0025:  add
+    IL_0026:  bne.un.s   IL_0011
+
+    IL_0028:  ret
+  } 
+
+  .method public static void  test2() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.2
+    IL_0004:  ldstr      "123"
+    IL_0009:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000e:  ldc.i4.1
+    IL_000f:  sub
+    IL_0010:  stloc.1
+    IL_0011:  ldloc.1
+    IL_0012:  ldloc.2
+    IL_0013:  blt.s      IL_0030
+
+    IL_0015:  ldstr      "123"
+    IL_001a:  ldloc.2
+    IL_001b:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0020:  stloc.3
+    IL_0021:  ldloc.0
+    IL_0022:  ldloc.3
+    IL_0023:  conv.i4
+    IL_0024:  add
+    IL_0025:  stloc.0
+    IL_0026:  ldloc.2
+    IL_0027:  ldc.i4.1
+    IL_0028:  add
+    IL_0029:  stloc.2
+    IL_002a:  ldloc.2
+    IL_002b:  ldloc.1
+    IL_002c:  ldc.i4.1
+    IL_002d:  add
+    IL_002e:  bne.un.s   IL_0015
+
+    IL_0030:  ret
+  } 
+
+  .method public static void  test3() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  stloc.0
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.2
+    IL_0005:  ldstr      "123"
+    IL_000a:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000f:  ldc.i4.1
+    IL_0010:  sub
+    IL_0011:  stloc.1
+    IL_0012:  ldloc.1
+    IL_0013:  ldloc.2
+    IL_0014:  blt.s      IL_0031
+
+    IL_0016:  ldstr      "123"
+    IL_001b:  ldloc.2
+    IL_001c:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0021:  stloc.3
+    IL_0022:  ldloc.0
+    IL_0023:  ldloc.3
+    IL_0024:  conv.i4
+    IL_0025:  add
+    IL_0026:  stloc.0
+    IL_0027:  ldloc.2
+    IL_0028:  ldc.i4.1
+    IL_0029:  add
+    IL_002a:  stloc.2
+    IL_002b:  ldloc.2
+    IL_002c:  ldloc.1
+    IL_002d:  ldc.i4.1
+    IL_002e:  add
+    IL_002f:  bne.un.s   IL_0016
+
+    IL_0031:  ret
+  } 
+
+  .method public static void  test4() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  nop
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.2
+    IL_0005:  ldstr      "123"
+    IL_000a:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000f:  ldc.i4.1
+    IL_0010:  sub
+    IL_0011:  stloc.1
+    IL_0012:  ldloc.1
+    IL_0013:  ldloc.2
+    IL_0014:  blt.s      IL_0031
+
+    IL_0016:  ldstr      "123"
+    IL_001b:  ldloc.2
+    IL_001c:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0021:  stloc.3
+    IL_0022:  ldloc.0
+    IL_0023:  ldloc.3
+    IL_0024:  conv.i4
+    IL_0025:  add
+    IL_0026:  stloc.0
+    IL_0027:  ldloc.2
+    IL_0028:  ldc.i4.1
+    IL_0029:  add
+    IL_002a:  stloc.2
+    IL_002b:  ldloc.2
+    IL_002c:  ldloc.1
+    IL_002d:  ldc.i4.1
+    IL_002e:  add
+    IL_002f:  bne.un.s   IL_0016
+
+    IL_0031:  ret
+  } 
+
+  .method public static void  test5() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             char V_2,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_3)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  stloc.1
+    IL_0003:  ldstr      "123"
+    IL_0008:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000d:  ldc.i4.1
+    IL_000e:  sub
+    IL_000f:  stloc.0
+    IL_0010:  ldloc.0
+    IL_0011:  ldloc.1
+    IL_0012:  blt.s      IL_0047
+
+    IL_0014:  ldstr      "123"
+    IL_0019:  ldloc.1
+    IL_001a:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_001f:  stloc.2
+    IL_0020:  ldstr      "%A"
+    IL_0025:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,char>::.ctor(string)
+    IL_002a:  stloc.3
+    IL_002b:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_0030:  ldloc.3
+    IL_0031:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0036:  ldloc.2
+    IL_0037:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_003c:  pop
+    IL_003d:  ldloc.1
+    IL_003e:  ldc.i4.1
+    IL_003f:  add
+    IL_0040:  stloc.1
+    IL_0041:  ldloc.1
+    IL_0042:  ldloc.0
+    IL_0043:  ldc.i4.1
+    IL_0044:  add
+    IL_0045:  bne.un.s   IL_0014
+
+    IL_0047:  ret
+  } 
+
+  .method public static void  test6(string str) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.2
+    IL_0004:  ldarg.0
+    IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000a:  ldc.i4.1
+    IL_000b:  sub
+    IL_000c:  stloc.1
+    IL_000d:  ldloc.1
+    IL_000e:  ldloc.2
+    IL_000f:  blt.s      IL_0028
+
+    IL_0011:  ldarg.0
+    IL_0012:  ldloc.2
+    IL_0013:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.0
+    IL_001a:  ldloc.3
+    IL_001b:  conv.i4
+    IL_001c:  add
+    IL_001d:  stloc.0
+    IL_001e:  ldloc.2
+    IL_001f:  ldc.i4.1
+    IL_0020:  add
+    IL_0021:  stloc.2
+    IL_0022:  ldloc.2
+    IL_0023:  ldloc.1
+    IL_0024:  ldc.i4.1
+    IL_0025:  add
+    IL_0026:  bne.un.s   IL_0011
+
+    IL_0028:  ret
+  } 
+
+  .method public static void  test7() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  stloc.0
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.2
+    IL_0005:  ldstr      "123"
+    IL_000a:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000f:  ldc.i4.1
+    IL_0010:  sub
+    IL_0011:  stloc.1
+    IL_0012:  ldloc.1
+    IL_0013:  ldloc.2
+    IL_0014:  blt.s      IL_0031
+
+    IL_0016:  ldstr      "123"
+    IL_001b:  ldloc.2
+    IL_001c:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0021:  stloc.3
+    IL_0022:  ldloc.0
+    IL_0023:  ldloc.3
+    IL_0024:  conv.i4
+    IL_0025:  add
+    IL_0026:  stloc.0
+    IL_0027:  ldloc.2
+    IL_0028:  ldc.i4.1
+    IL_0029:  add
+    IL_002a:  stloc.2
+    IL_002b:  ldloc.2
+    IL_002c:  ldloc.1
+    IL_002d:  ldc.i4.1
+    IL_002e:  add
+    IL_002f:  bne.un.s   IL_0016
+
+    IL_0031:  ret
+  } 
+
+  .method public static void  test8() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (string V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_4)
+    IL_0000:  ldsfld     class assembly/test8@54 assembly/test8@54::@_instance
+    IL_0005:  ldstr      "1234"
+    IL_000a:  call       string [FSharp.Core]Microsoft.FSharp.Core.StringModule::Map(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>,
+                                                                                     string)
+    IL_000f:  stloc.0
+    IL_0010:  ldc.i4.0
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.0
+    IL_0013:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_0018:  ldc.i4.1
+    IL_0019:  sub
+    IL_001a:  stloc.1
+    IL_001b:  ldloc.1
+    IL_001c:  ldloc.2
+    IL_001d:  blt.s      IL_0050
+
+    IL_001f:  ldloc.0
+    IL_0020:  ldloc.2
+    IL_0021:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0026:  stloc.3
+    IL_0027:  ldstr      "%O"
+    IL_002c:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,char>::.ctor(string)
+    IL_0031:  stloc.s    V_4
+    IL_0033:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_0038:  ldloc.s    V_4
+    IL_003a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_003f:  ldloc.3
+    IL_0040:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0045:  pop
+    IL_0046:  ldloc.2
+    IL_0047:  ldc.i4.1
+    IL_0048:  add
+    IL_0049:  stloc.2
+    IL_004a:  ldloc.2
+    IL_004b:  ldloc.1
+    IL_004c:  ldc.i4.1
+    IL_004d:  add
+    IL_004e:  bne.un.s   IL_001f
+
+    IL_0050:  ret
+  } 
+
+  .method public static void  test9() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (string V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3,
+             string V_4,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_5)
+    IL_0000:  ldsfld     class assembly/test9@63 assembly/test9@63::@_instance
+    IL_0005:  ldstr      "1234"
+    IL_000a:  call       string [FSharp.Core]Microsoft.FSharp.Core.StringModule::Map(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>,
+                                                                                     string)
+    IL_000f:  stloc.0
+    IL_0010:  ldc.i4.0
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.0
+    IL_0013:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_0018:  ldc.i4.1
+    IL_0019:  sub
+    IL_001a:  stloc.1
+    IL_001b:  ldloc.1
+    IL_001c:  ldloc.2
+    IL_001d:  blt.s      IL_0063
+
+    IL_001f:  ldloc.0
+    IL_0020:  ldloc.2
+    IL_0021:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0026:  stloc.3
+    IL_0027:  ldstr      "{0} foo"
+    IL_002c:  ldloc.3
+    IL_002d:  box        [runtime]System.Char
+    IL_0032:  call       string [runtime]System.String::Format(string,
+                                                                object)
+    IL_0037:  stloc.s    V_4
+    IL_0039:  ldstr      "%O"
+    IL_003e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string>::.ctor(string)
+    IL_0043:  stloc.s    V_5
+    IL_0045:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_004a:  ldloc.s    V_5
+    IL_004c:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0051:  ldloc.s    V_4
+    IL_0053:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0058:  pop
+    IL_0059:  ldloc.2
+    IL_005a:  ldc.i4.1
+    IL_005b:  add
+    IL_005c:  stloc.2
+    IL_005d:  ldloc.2
+    IL_005e:  ldloc.1
+    IL_005f:  ldc.i4.1
+    IL_0060:  add
+    IL_0061:  bne.un.s   IL_001f
+
+    IL_0063:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnString01.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnString01.fs.il.netcore.debug.bsl
new file mode 100644
index 00000000000..c56fef87382
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnString01.fs.il.netcore.debug.bsl
@@ -0,0 +1,556 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit test8@54
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>
+  {
+    .field static assembly initonly class assembly/test8@54 @_instance
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance char 
+            Invoke(char x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  conv.i4
+      IL_0002:  ldc.i4.1
+      IL_0003:  add
+      IL_0004:  conv.u2
+      IL_0005:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/test8@54::.ctor()
+      IL_0005:  stsfld     class assembly/test8@54 assembly/test8@54::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit test9@63
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>
+  {
+    .field static assembly initonly class assembly/test9@63 @_instance
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance char 
+            Invoke(char x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  conv.i4
+      IL_0002:  ldc.i4.1
+      IL_0003:  add
+      IL_0004:  conv.u2
+      IL_0005:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/test9@63::.ctor()
+      IL_0005:  stsfld     class assembly/test9@63 assembly/test9@63::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .method public static void  test1(string str) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.2
+    IL_0004:  ldarg.0
+    IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000a:  ldc.i4.1
+    IL_000b:  sub
+    IL_000c:  stloc.1
+    IL_000d:  ldloc.1
+    IL_000e:  ldloc.2
+    IL_000f:  blt.s      IL_0028
+
+    IL_0011:  ldarg.0
+    IL_0012:  ldloc.2
+    IL_0013:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.0
+    IL_001a:  ldloc.3
+    IL_001b:  conv.i4
+    IL_001c:  add
+    IL_001d:  stloc.0
+    IL_001e:  ldloc.2
+    IL_001f:  ldc.i4.1
+    IL_0020:  add
+    IL_0021:  stloc.2
+    IL_0022:  ldloc.2
+    IL_0023:  ldloc.1
+    IL_0024:  ldc.i4.1
+    IL_0025:  add
+    IL_0026:  bne.un.s   IL_0011
+
+    IL_0028:  ret
+  } 
+
+  .method public static void  test2() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.2
+    IL_0004:  ldstr      "123"
+    IL_0009:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000e:  ldc.i4.1
+    IL_000f:  sub
+    IL_0010:  stloc.1
+    IL_0011:  ldloc.1
+    IL_0012:  ldloc.2
+    IL_0013:  blt.s      IL_0030
+
+    IL_0015:  ldstr      "123"
+    IL_001a:  ldloc.2
+    IL_001b:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0020:  stloc.3
+    IL_0021:  ldloc.0
+    IL_0022:  ldloc.3
+    IL_0023:  conv.i4
+    IL_0024:  add
+    IL_0025:  stloc.0
+    IL_0026:  ldloc.2
+    IL_0027:  ldc.i4.1
+    IL_0028:  add
+    IL_0029:  stloc.2
+    IL_002a:  ldloc.2
+    IL_002b:  ldloc.1
+    IL_002c:  ldc.i4.1
+    IL_002d:  add
+    IL_002e:  bne.un.s   IL_0015
+
+    IL_0030:  ret
+  } 
+
+  .method public static void  test3() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  stloc.0
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.2
+    IL_0005:  ldstr      "123"
+    IL_000a:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000f:  ldc.i4.1
+    IL_0010:  sub
+    IL_0011:  stloc.1
+    IL_0012:  ldloc.1
+    IL_0013:  ldloc.2
+    IL_0014:  blt.s      IL_0031
+
+    IL_0016:  ldstr      "123"
+    IL_001b:  ldloc.2
+    IL_001c:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0021:  stloc.3
+    IL_0022:  ldloc.0
+    IL_0023:  ldloc.3
+    IL_0024:  conv.i4
+    IL_0025:  add
+    IL_0026:  stloc.0
+    IL_0027:  ldloc.2
+    IL_0028:  ldc.i4.1
+    IL_0029:  add
+    IL_002a:  stloc.2
+    IL_002b:  ldloc.2
+    IL_002c:  ldloc.1
+    IL_002d:  ldc.i4.1
+    IL_002e:  add
+    IL_002f:  bne.un.s   IL_0016
+
+    IL_0031:  ret
+  } 
+
+  .method public static void  test4() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  nop
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.2
+    IL_0005:  ldstr      "123"
+    IL_000a:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000f:  ldc.i4.1
+    IL_0010:  sub
+    IL_0011:  stloc.1
+    IL_0012:  ldloc.1
+    IL_0013:  ldloc.2
+    IL_0014:  blt.s      IL_0031
+
+    IL_0016:  ldstr      "123"
+    IL_001b:  ldloc.2
+    IL_001c:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0021:  stloc.3
+    IL_0022:  ldloc.0
+    IL_0023:  ldloc.3
+    IL_0024:  conv.i4
+    IL_0025:  add
+    IL_0026:  stloc.0
+    IL_0027:  ldloc.2
+    IL_0028:  ldc.i4.1
+    IL_0029:  add
+    IL_002a:  stloc.2
+    IL_002b:  ldloc.2
+    IL_002c:  ldloc.1
+    IL_002d:  ldc.i4.1
+    IL_002e:  add
+    IL_002f:  bne.un.s   IL_0016
+
+    IL_0031:  ret
+  } 
+
+  .method public static void  test5() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             char V_2)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  stloc.1
+    IL_0003:  ldstr      "123"
+    IL_0008:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000d:  ldc.i4.1
+    IL_000e:  sub
+    IL_000f:  stloc.0
+    IL_0010:  ldloc.0
+    IL_0011:  ldloc.1
+    IL_0012:  blt.s      IL_0040
+
+    IL_0014:  ldstr      "123"
+    IL_0019:  ldloc.1
+    IL_001a:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_001f:  stloc.2
+    IL_0020:  ldstr      "%A"
+    IL_0025:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,char>::.ctor(string)
+    IL_002a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_002f:  ldloc.2
+    IL_0030:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0035:  pop
+    IL_0036:  ldloc.1
+    IL_0037:  ldc.i4.1
+    IL_0038:  add
+    IL_0039:  stloc.1
+    IL_003a:  ldloc.1
+    IL_003b:  ldloc.0
+    IL_003c:  ldc.i4.1
+    IL_003d:  add
+    IL_003e:  bne.un.s   IL_0014
+
+    IL_0040:  ret
+  } 
+
+  .method public static void  test6(string str) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.2
+    IL_0004:  ldarg.0
+    IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000a:  ldc.i4.1
+    IL_000b:  sub
+    IL_000c:  stloc.1
+    IL_000d:  ldloc.1
+    IL_000e:  ldloc.2
+    IL_000f:  blt.s      IL_0028
+
+    IL_0011:  ldarg.0
+    IL_0012:  ldloc.2
+    IL_0013:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.0
+    IL_001a:  ldloc.3
+    IL_001b:  conv.i4
+    IL_001c:  add
+    IL_001d:  stloc.0
+    IL_001e:  ldloc.2
+    IL_001f:  ldc.i4.1
+    IL_0020:  add
+    IL_0021:  stloc.2
+    IL_0022:  ldloc.2
+    IL_0023:  ldloc.1
+    IL_0024:  ldc.i4.1
+    IL_0025:  add
+    IL_0026:  bne.un.s   IL_0011
+
+    IL_0028:  ret
+  } 
+
+  .method public static void  test7() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  stloc.0
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.2
+    IL_0005:  ldstr      "123"
+    IL_000a:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000f:  ldc.i4.1
+    IL_0010:  sub
+    IL_0011:  stloc.1
+    IL_0012:  ldloc.1
+    IL_0013:  ldloc.2
+    IL_0014:  blt.s      IL_0031
+
+    IL_0016:  ldstr      "123"
+    IL_001b:  ldloc.2
+    IL_001c:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0021:  stloc.3
+    IL_0022:  ldloc.0
+    IL_0023:  ldloc.3
+    IL_0024:  conv.i4
+    IL_0025:  add
+    IL_0026:  stloc.0
+    IL_0027:  ldloc.2
+    IL_0028:  ldc.i4.1
+    IL_0029:  add
+    IL_002a:  stloc.2
+    IL_002b:  ldloc.2
+    IL_002c:  ldloc.1
+    IL_002d:  ldc.i4.1
+    IL_002e:  add
+    IL_002f:  bne.un.s   IL_0016
+
+    IL_0031:  ret
+  } 
+
+  .method public static void  test8() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (string V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldsfld     class assembly/test8@54 assembly/test8@54::@_instance
+    IL_0005:  ldstr      "1234"
+    IL_000a:  call       string [FSharp.Core]Microsoft.FSharp.Core.StringModule::Map(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>,
+                                                                                     string)
+    IL_000f:  stloc.0
+    IL_0010:  ldc.i4.0
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.0
+    IL_0013:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_0018:  ldc.i4.1
+    IL_0019:  sub
+    IL_001a:  stloc.1
+    IL_001b:  ldloc.1
+    IL_001c:  ldloc.2
+    IL_001d:  blt.s      IL_0047
+
+    IL_001f:  ldloc.0
+    IL_0020:  ldloc.2
+    IL_0021:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0026:  stloc.3
+    IL_0027:  ldstr      "%O"
+    IL_002c:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,char>::.ctor(string)
+    IL_0031:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0036:  ldloc.3
+    IL_0037:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_003c:  pop
+    IL_003d:  ldloc.2
+    IL_003e:  ldc.i4.1
+    IL_003f:  add
+    IL_0040:  stloc.2
+    IL_0041:  ldloc.2
+    IL_0042:  ldloc.1
+    IL_0043:  ldc.i4.1
+    IL_0044:  add
+    IL_0045:  bne.un.s   IL_001f
+
+    IL_0047:  ret
+  } 
+
+  .method public static void  test9() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (string V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3,
+             string V_4)
+    IL_0000:  ldsfld     class assembly/test9@63 assembly/test9@63::@_instance
+    IL_0005:  ldstr      "1234"
+    IL_000a:  call       string [FSharp.Core]Microsoft.FSharp.Core.StringModule::Map(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>,
+                                                                                     string)
+    IL_000f:  stloc.0
+    IL_0010:  ldc.i4.0
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.0
+    IL_0013:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_0018:  ldc.i4.1
+    IL_0019:  sub
+    IL_001a:  stloc.1
+    IL_001b:  ldloc.1
+    IL_001c:  ldloc.2
+    IL_001d:  blt.s      IL_005a
+
+    IL_001f:  ldloc.0
+    IL_0020:  ldloc.2
+    IL_0021:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0026:  stloc.3
+    IL_0027:  ldstr      "{0} foo"
+    IL_002c:  ldloc.3
+    IL_002d:  box        [runtime]System.Char
+    IL_0032:  call       string [runtime]System.String::Format(string,
+                                                                      object)
+    IL_0037:  stloc.s    V_4
+    IL_0039:  ldstr      "%O"
+    IL_003e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string>::.ctor(string)
+    IL_0043:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0048:  ldloc.s    V_4
+    IL_004a:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_004f:  pop
+    IL_0050:  ldloc.2
+    IL_0051:  ldc.i4.1
+    IL_0052:  add
+    IL_0053:  stloc.2
+    IL_0054:  ldloc.2
+    IL_0055:  ldloc.1
+    IL_0056:  ldc.i4.1
+    IL_0057:  add
+    IL_0058:  bne.un.s   IL_001f
+
+    IL_005a:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnString01.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnString01.fs.il.netcore.release.bsl
new file mode 100644
index 00000000000..66b3dcc4d84
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForEachOnString01.fs.il.netcore.release.bsl
@@ -0,0 +1,571 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit test8@54
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>
+  {
+    .field static assembly initonly class assembly/test8@54 @_instance
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance char 
+            Invoke(char x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  conv.i4
+      IL_0002:  ldc.i4.1
+      IL_0003:  add
+      IL_0004:  conv.u2
+      IL_0005:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/test8@54::.ctor()
+      IL_0005:  stsfld     class assembly/test8@54 assembly/test8@54::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit test9@63
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>
+  {
+    .field static assembly initonly class assembly/test9@63 @_instance
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance char 
+            Invoke(char x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  conv.i4
+      IL_0002:  ldc.i4.1
+      IL_0003:  add
+      IL_0004:  conv.u2
+      IL_0005:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/test9@63::.ctor()
+      IL_0005:  stsfld     class assembly/test9@63 assembly/test9@63::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .method public static void  test1(string str) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.2
+    IL_0004:  ldarg.0
+    IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000a:  ldc.i4.1
+    IL_000b:  sub
+    IL_000c:  stloc.1
+    IL_000d:  ldloc.1
+    IL_000e:  ldloc.2
+    IL_000f:  blt.s      IL_0028
+
+    IL_0011:  ldarg.0
+    IL_0012:  ldloc.2
+    IL_0013:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.0
+    IL_001a:  ldloc.3
+    IL_001b:  conv.i4
+    IL_001c:  add
+    IL_001d:  stloc.0
+    IL_001e:  ldloc.2
+    IL_001f:  ldc.i4.1
+    IL_0020:  add
+    IL_0021:  stloc.2
+    IL_0022:  ldloc.2
+    IL_0023:  ldloc.1
+    IL_0024:  ldc.i4.1
+    IL_0025:  add
+    IL_0026:  bne.un.s   IL_0011
+
+    IL_0028:  ret
+  } 
+
+  .method public static void  test2() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.2
+    IL_0004:  ldstr      "123"
+    IL_0009:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000e:  ldc.i4.1
+    IL_000f:  sub
+    IL_0010:  stloc.1
+    IL_0011:  ldloc.1
+    IL_0012:  ldloc.2
+    IL_0013:  blt.s      IL_0030
+
+    IL_0015:  ldstr      "123"
+    IL_001a:  ldloc.2
+    IL_001b:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0020:  stloc.3
+    IL_0021:  ldloc.0
+    IL_0022:  ldloc.3
+    IL_0023:  conv.i4
+    IL_0024:  add
+    IL_0025:  stloc.0
+    IL_0026:  ldloc.2
+    IL_0027:  ldc.i4.1
+    IL_0028:  add
+    IL_0029:  stloc.2
+    IL_002a:  ldloc.2
+    IL_002b:  ldloc.1
+    IL_002c:  ldc.i4.1
+    IL_002d:  add
+    IL_002e:  bne.un.s   IL_0015
+
+    IL_0030:  ret
+  } 
+
+  .method public static void  test3() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  stloc.0
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.2
+    IL_0005:  ldstr      "123"
+    IL_000a:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000f:  ldc.i4.1
+    IL_0010:  sub
+    IL_0011:  stloc.1
+    IL_0012:  ldloc.1
+    IL_0013:  ldloc.2
+    IL_0014:  blt.s      IL_0031
+
+    IL_0016:  ldstr      "123"
+    IL_001b:  ldloc.2
+    IL_001c:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0021:  stloc.3
+    IL_0022:  ldloc.0
+    IL_0023:  ldloc.3
+    IL_0024:  conv.i4
+    IL_0025:  add
+    IL_0026:  stloc.0
+    IL_0027:  ldloc.2
+    IL_0028:  ldc.i4.1
+    IL_0029:  add
+    IL_002a:  stloc.2
+    IL_002b:  ldloc.2
+    IL_002c:  ldloc.1
+    IL_002d:  ldc.i4.1
+    IL_002e:  add
+    IL_002f:  bne.un.s   IL_0016
+
+    IL_0031:  ret
+  } 
+
+  .method public static void  test4() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  nop
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.2
+    IL_0005:  ldstr      "123"
+    IL_000a:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000f:  ldc.i4.1
+    IL_0010:  sub
+    IL_0011:  stloc.1
+    IL_0012:  ldloc.1
+    IL_0013:  ldloc.2
+    IL_0014:  blt.s      IL_0031
+
+    IL_0016:  ldstr      "123"
+    IL_001b:  ldloc.2
+    IL_001c:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0021:  stloc.3
+    IL_0022:  ldloc.0
+    IL_0023:  ldloc.3
+    IL_0024:  conv.i4
+    IL_0025:  add
+    IL_0026:  stloc.0
+    IL_0027:  ldloc.2
+    IL_0028:  ldc.i4.1
+    IL_0029:  add
+    IL_002a:  stloc.2
+    IL_002b:  ldloc.2
+    IL_002c:  ldloc.1
+    IL_002d:  ldc.i4.1
+    IL_002e:  add
+    IL_002f:  bne.un.s   IL_0016
+
+    IL_0031:  ret
+  } 
+
+  .method public static void  test5() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             char V_2,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_3)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  stloc.1
+    IL_0003:  ldstr      "123"
+    IL_0008:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000d:  ldc.i4.1
+    IL_000e:  sub
+    IL_000f:  stloc.0
+    IL_0010:  ldloc.0
+    IL_0011:  ldloc.1
+    IL_0012:  blt.s      IL_0047
+
+    IL_0014:  ldstr      "123"
+    IL_0019:  ldloc.1
+    IL_001a:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_001f:  stloc.2
+    IL_0020:  ldstr      "%A"
+    IL_0025:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,char>::.ctor(string)
+    IL_002a:  stloc.3
+    IL_002b:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_0030:  ldloc.3
+    IL_0031:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0036:  ldloc.2
+    IL_0037:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_003c:  pop
+    IL_003d:  ldloc.1
+    IL_003e:  ldc.i4.1
+    IL_003f:  add
+    IL_0040:  stloc.1
+    IL_0041:  ldloc.1
+    IL_0042:  ldloc.0
+    IL_0043:  ldc.i4.1
+    IL_0044:  add
+    IL_0045:  bne.un.s   IL_0014
+
+    IL_0047:  ret
+  } 
+
+  .method public static void  test6(string str) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.2
+    IL_0004:  ldarg.0
+    IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000a:  ldc.i4.1
+    IL_000b:  sub
+    IL_000c:  stloc.1
+    IL_000d:  ldloc.1
+    IL_000e:  ldloc.2
+    IL_000f:  blt.s      IL_0028
+
+    IL_0011:  ldarg.0
+    IL_0012:  ldloc.2
+    IL_0013:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.0
+    IL_001a:  ldloc.3
+    IL_001b:  conv.i4
+    IL_001c:  add
+    IL_001d:  stloc.0
+    IL_001e:  ldloc.2
+    IL_001f:  ldc.i4.1
+    IL_0020:  add
+    IL_0021:  stloc.2
+    IL_0022:  ldloc.2
+    IL_0023:  ldloc.1
+    IL_0024:  ldc.i4.1
+    IL_0025:  add
+    IL_0026:  bne.un.s   IL_0011
+
+    IL_0028:  ret
+  } 
+
+  .method public static void  test7() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  stloc.0
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.2
+    IL_0005:  ldstr      "123"
+    IL_000a:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000f:  ldc.i4.1
+    IL_0010:  sub
+    IL_0011:  stloc.1
+    IL_0012:  ldloc.1
+    IL_0013:  ldloc.2
+    IL_0014:  blt.s      IL_0031
+
+    IL_0016:  ldstr      "123"
+    IL_001b:  ldloc.2
+    IL_001c:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0021:  stloc.3
+    IL_0022:  ldloc.0
+    IL_0023:  ldloc.3
+    IL_0024:  conv.i4
+    IL_0025:  add
+    IL_0026:  stloc.0
+    IL_0027:  ldloc.2
+    IL_0028:  ldc.i4.1
+    IL_0029:  add
+    IL_002a:  stloc.2
+    IL_002b:  ldloc.2
+    IL_002c:  ldloc.1
+    IL_002d:  ldc.i4.1
+    IL_002e:  add
+    IL_002f:  bne.un.s   IL_0016
+
+    IL_0031:  ret
+  } 
+
+  .method public static void  test8() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (string V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_4)
+    IL_0000:  ldsfld     class assembly/test8@54 assembly/test8@54::@_instance
+    IL_0005:  ldstr      "1234"
+    IL_000a:  call       string [FSharp.Core]Microsoft.FSharp.Core.StringModule::Map(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>,
+                                                                                     string)
+    IL_000f:  stloc.0
+    IL_0010:  ldc.i4.0
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.0
+    IL_0013:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_0018:  ldc.i4.1
+    IL_0019:  sub
+    IL_001a:  stloc.1
+    IL_001b:  ldloc.1
+    IL_001c:  ldloc.2
+    IL_001d:  blt.s      IL_0050
+
+    IL_001f:  ldloc.0
+    IL_0020:  ldloc.2
+    IL_0021:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0026:  stloc.3
+    IL_0027:  ldstr      "%O"
+    IL_002c:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,char>::.ctor(string)
+    IL_0031:  stloc.s    V_4
+    IL_0033:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_0038:  ldloc.s    V_4
+    IL_003a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_003f:  ldloc.3
+    IL_0040:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0045:  pop
+    IL_0046:  ldloc.2
+    IL_0047:  ldc.i4.1
+    IL_0048:  add
+    IL_0049:  stloc.2
+    IL_004a:  ldloc.2
+    IL_004b:  ldloc.1
+    IL_004c:  ldc.i4.1
+    IL_004d:  add
+    IL_004e:  bne.un.s   IL_001f
+
+    IL_0050:  ret
+  } 
+
+  .method public static void  test9() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (string V_0,
+             int32 V_1,
+             int32 V_2,
+             char V_3,
+             string V_4,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_5)
+    IL_0000:  ldsfld     class assembly/test9@63 assembly/test9@63::@_instance
+    IL_0005:  ldstr      "1234"
+    IL_000a:  call       string [FSharp.Core]Microsoft.FSharp.Core.StringModule::Map(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>,
+                                                                                     string)
+    IL_000f:  stloc.0
+    IL_0010:  ldc.i4.0
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.0
+    IL_0013:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_0018:  ldc.i4.1
+    IL_0019:  sub
+    IL_001a:  stloc.1
+    IL_001b:  ldloc.1
+    IL_001c:  ldloc.2
+    IL_001d:  blt.s      IL_0063
+
+    IL_001f:  ldloc.0
+    IL_0020:  ldloc.2
+    IL_0021:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+    IL_0026:  stloc.3
+    IL_0027:  ldstr      "{0} foo"
+    IL_002c:  ldloc.3
+    IL_002d:  box        [runtime]System.Char
+    IL_0032:  call       string [runtime]System.String::Format(string,
+                                                                      object)
+    IL_0037:  stloc.s    V_4
+    IL_0039:  ldstr      "%O"
+    IL_003e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string>::.ctor(string)
+    IL_0043:  stloc.s    V_5
+    IL_0045:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_004a:  ldloc.s    V_5
+    IL_004c:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0051:  ldloc.s    V_4
+    IL_0053:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0058:  pop
+    IL_0059:  ldloc.2
+    IL_005a:  ldc.i4.1
+    IL_005b:  add
+    IL_005c:  stloc.2
+    IL_005d:  ldloc.2
+    IL_005e:  ldloc.1
+    IL_005f:  ldc.i4.1
+    IL_0060:  add
+    IL_0061:  bne.un.s   IL_001f
+
+    IL_0063:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoop.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForLoop.fs
similarity index 98%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoop.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForLoop.fs
index 22607c2542c..f98947c030b 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/ForLoop.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ForLoop.fs
@@ -1,10 +1,10 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open Xunit
 open FSharp.Test
 open FSharp.Test.Compiler
 
-module ForLoop =
+module ForLoopRealInternalSignatureOn =
 
     let verifyCompilation compilation =
         compilation
@@ -14,6 +14,7 @@ module ForLoop =
         |> withEmbeddedPdb
         |> withEmbedAllSource
         |> ignoreWarnings
+        |> withRealInternalSignatureOn
         |> verifyILBaseline
 
     // SOURCE=NoAllocationOfTuple01.fs SCFLAGS="-a -g --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd NoAllocationOfTuple01.dll" # NoAllocationOfTuple01.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoAllocationOfTuple01.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoAllocationOfTuple01.fs
new file mode 100644
index 00000000000..54c5dd3c27c
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoAllocationOfTuple01.fs
@@ -0,0 +1,11 @@
+// #Regression #CodeGen #Optimizations #ControlFlow #NoMono #ReqNOMT 
+// Regression test for FSHARP1.0:5408
+// For-loop emitted with unnecessary tuple
+module NoAllocationOfTuple01
+let loop n =
+    let a = Array.zeroCreate n 
+    let mutable i = -1
+    for j = 1 to n do
+      i <- i + 1 
+      a.[ i ] <- j // creates an unnecessary temporary tuple
+    a
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoAllocationOfTuple01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoAllocationOfTuple01.fs.il.bsl
new file mode 100644
index 00000000000..e43120841d9
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoAllocationOfTuple01.fs.il.bsl
@@ -0,0 +1,108 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static int32[]  loop(int32 n) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32[] V_0,
+             int32 V_1,
+             int32 V_2,
+             int32 V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::ZeroCreate<int32>(int32)
+    IL_0006:  stloc.0
+    IL_0007:  ldc.i4.m1
+    IL_0008:  stloc.1
+    IL_0009:  ldc.i4.1
+    IL_000a:  stloc.3
+    IL_000b:  ldarg.0
+    IL_000c:  stloc.2
+    IL_000d:  ldloc.2
+    IL_000e:  ldloc.3
+    IL_000f:  blt.s      IL_0027
+
+    IL_0011:  ldloc.1
+    IL_0012:  ldc.i4.1
+    IL_0013:  add
+    IL_0014:  stloc.1
+    IL_0015:  ldloc.0
+    IL_0016:  ldloc.1
+    IL_0017:  ldloc.3
+    IL_0018:  stelem     [runtime]System.Int32
+    IL_001d:  ldloc.3
+    IL_001e:  ldc.i4.1
+    IL_001f:  add
+    IL_0020:  stloc.3
+    IL_0021:  ldloc.3
+    IL_0022:  ldloc.2
+    IL_0023:  ldc.i4.1
+    IL_0024:  add
+    IL_0025:  bne.un.s   IL_0011
+
+    IL_0027:  ldloc.0
+    IL_0028:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable01.fsx b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable01.fsx
new file mode 100644
index 00000000000..6c6ab9e6c2f
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable01.fsx
@@ -0,0 +1,8 @@
+// #Regression #CodeGen #Optimizations #ControlFlow #NoMono #ReqNOMT 
+// Regression test for FSHARP1.0:6064
+
+module M
+
+let loop1 N =
+   for i in 1 .. N do
+      printfn "aaa"
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable01.fsx.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable01.fsx.il.net472.debug.bsl
new file mode 100644
index 00000000000..4c0acb5b6ba
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable01.fsx.il.net472.debug.bsl
@@ -0,0 +1,96 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  loop1(int32 N) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldc.i4.1
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.0
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0022
+
+    IL_0008:  ldstr      "aaa"
+    IL_000d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_0012:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0017:  pop
+    IL_0018:  ldloc.1
+    IL_0019:  ldc.i4.1
+    IL_001a:  add
+    IL_001b:  stloc.1
+    IL_001c:  ldloc.1
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.1
+    IL_001f:  add
+    IL_0020:  bne.un.s   IL_0008
+
+    IL_0022:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M$fsx
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable01.fsx.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable01.fsx.il.net472.release.bsl
new file mode 100644
index 00000000000..1c1f3221262
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable01.fsx.il.net472.release.bsl
@@ -0,0 +1,106 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  loop1(int32 N) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_2)
+    IL_0000:  ldc.i4.1
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.0
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0029
+
+    IL_0008:  ldstr      "aaa"
+    IL_000d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_0012:  stloc.2
+    IL_0013:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_0018:  ldloc.2
+    IL_0019:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_001e:  pop
+    IL_001f:  ldloc.1
+    IL_0020:  ldc.i4.1
+    IL_0021:  add
+    IL_0022:  stloc.1
+    IL_0023:  ldloc.1
+    IL_0024:  ldloc.0
+    IL_0025:  ldc.i4.1
+    IL_0026:  add
+    IL_0027:  bne.un.s   IL_0008
+
+    IL_0029:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M$fsx
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable01.fsx.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable01.fsx.il.netcore.debug.bsl
new file mode 100644
index 00000000000..4c0acb5b6ba
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable01.fsx.il.netcore.debug.bsl
@@ -0,0 +1,96 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  loop1(int32 N) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldc.i4.1
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.0
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0022
+
+    IL_0008:  ldstr      "aaa"
+    IL_000d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_0012:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0017:  pop
+    IL_0018:  ldloc.1
+    IL_0019:  ldc.i4.1
+    IL_001a:  add
+    IL_001b:  stloc.1
+    IL_001c:  ldloc.1
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.1
+    IL_001f:  add
+    IL_0020:  bne.un.s   IL_0008
+
+    IL_0022:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M$fsx
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable01.fsx.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable01.fsx.il.netcore.release.bsl
new file mode 100644
index 00000000000..51a1fd29773
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable01.fsx.il.netcore.release.bsl
@@ -0,0 +1,106 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  loop1(int32 N) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_2)
+    IL_0000:  ldc.i4.1
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.0
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0029
+
+    IL_0008:  ldstr      "aaa"
+    IL_000d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_0012:  stloc.2
+    IL_0013:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_0018:  ldloc.2
+    IL_0019:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_001e:  pop
+    IL_001f:  ldloc.1
+    IL_0020:  ldc.i4.1
+    IL_0021:  add
+    IL_0022:  stloc.1
+    IL_0023:  ldloc.1
+    IL_0024:  ldloc.0
+    IL_0025:  ldc.i4.1
+    IL_0026:  add
+    IL_0027:  bne.un.s   IL_0008
+
+    IL_0029:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M$fsx
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable02.fsx b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable02.fsx
new file mode 100644
index 00000000000..14fa58c1458
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable02.fsx
@@ -0,0 +1,8 @@
+// #Regression #CodeGen #Optimizations #ControlFlow #NoMono #ReqNOMT 
+// Regression test for FSHARP1.0:6064
+
+module M
+
+let loop2 N =
+   for i in 100 .. N do
+      printfn "aaa"
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable02.fsx.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable02.fsx.il.net472.debug.bsl
new file mode 100644
index 00000000000..e31d59290d9
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable02.fsx.il.net472.debug.bsl
@@ -0,0 +1,96 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  loop2(int32 N) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldc.i4.s   100
+    IL_0002:  stloc.1
+    IL_0003:  ldarg.0
+    IL_0004:  stloc.0
+    IL_0005:  ldloc.0
+    IL_0006:  ldloc.1
+    IL_0007:  blt.s      IL_0023
+
+    IL_0009:  ldstr      "aaa"
+    IL_000e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_0013:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0018:  pop
+    IL_0019:  ldloc.1
+    IL_001a:  ldc.i4.1
+    IL_001b:  add
+    IL_001c:  stloc.1
+    IL_001d:  ldloc.1
+    IL_001e:  ldloc.0
+    IL_001f:  ldc.i4.1
+    IL_0020:  add
+    IL_0021:  bne.un.s   IL_0009
+
+    IL_0023:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M$fsx
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable02.fsx.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable02.fsx.il.net472.release.bsl
new file mode 100644
index 00000000000..5db215b7499
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable02.fsx.il.net472.release.bsl
@@ -0,0 +1,106 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  loop2(int32 N) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_2)
+    IL_0000:  ldc.i4.s   100
+    IL_0002:  stloc.1
+    IL_0003:  ldarg.0
+    IL_0004:  stloc.0
+    IL_0005:  ldloc.0
+    IL_0006:  ldloc.1
+    IL_0007:  blt.s      IL_002a
+
+    IL_0009:  ldstr      "aaa"
+    IL_000e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_0013:  stloc.2
+    IL_0014:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_0019:  ldloc.2
+    IL_001a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_001f:  pop
+    IL_0020:  ldloc.1
+    IL_0021:  ldc.i4.1
+    IL_0022:  add
+    IL_0023:  stloc.1
+    IL_0024:  ldloc.1
+    IL_0025:  ldloc.0
+    IL_0026:  ldc.i4.1
+    IL_0027:  add
+    IL_0028:  bne.un.s   IL_0009
+
+    IL_002a:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M$fsx
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable02.fsx.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable02.fsx.il.netcore.debug.bsl
new file mode 100644
index 00000000000..e31d59290d9
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable02.fsx.il.netcore.debug.bsl
@@ -0,0 +1,96 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  loop2(int32 N) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldc.i4.s   100
+    IL_0002:  stloc.1
+    IL_0003:  ldarg.0
+    IL_0004:  stloc.0
+    IL_0005:  ldloc.0
+    IL_0006:  ldloc.1
+    IL_0007:  blt.s      IL_0023
+
+    IL_0009:  ldstr      "aaa"
+    IL_000e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_0013:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0018:  pop
+    IL_0019:  ldloc.1
+    IL_001a:  ldc.i4.1
+    IL_001b:  add
+    IL_001c:  stloc.1
+    IL_001d:  ldloc.1
+    IL_001e:  ldloc.0
+    IL_001f:  ldc.i4.1
+    IL_0020:  add
+    IL_0021:  bne.un.s   IL_0009
+
+    IL_0023:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M$fsx
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable02.fsx.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable02.fsx.il.netcore.release.bsl
new file mode 100644
index 00000000000..1e7f43d17e9
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable02.fsx.il.netcore.release.bsl
@@ -0,0 +1,106 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  loop2(int32 N) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_2)
+    IL_0000:  ldc.i4.s   100
+    IL_0002:  stloc.1
+    IL_0003:  ldarg.0
+    IL_0004:  stloc.0
+    IL_0005:  ldloc.0
+    IL_0006:  ldloc.1
+    IL_0007:  blt.s      IL_002a
+
+    IL_0009:  ldstr      "aaa"
+    IL_000e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_0013:  stloc.2
+    IL_0014:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_0019:  ldloc.2
+    IL_001a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_001f:  pop
+    IL_0020:  ldloc.1
+    IL_0021:  ldc.i4.1
+    IL_0022:  add
+    IL_0023:  stloc.1
+    IL_0024:  ldloc.1
+    IL_0025:  ldloc.0
+    IL_0026:  ldc.i4.1
+    IL_0027:  add
+    IL_0028:  bne.un.s   IL_0009
+
+    IL_002a:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M$fsx
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable03.fsx b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable03.fsx
new file mode 100644
index 00000000000..a445b6fd3dd
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable03.fsx
@@ -0,0 +1,9 @@
+// #Regression #CodeGen #Optimizations #ControlFlow #NoMono #ReqNOMT 
+// Regression test for FSHARP1.0:6064
+
+module M
+
+let loop3 a N = 
+   for i in a .. N do
+      printfn "aaa"
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable03.fsx.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable03.fsx.il.net472.debug.bsl
new file mode 100644
index 00000000000..c580ba49eec
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable03.fsx.il.net472.debug.bsl
@@ -0,0 +1,98 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  loop3(int32 a,
+                                    int32 N) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0022
+
+    IL_0008:  ldstr      "aaa"
+    IL_000d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_0012:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0017:  pop
+    IL_0018:  ldloc.1
+    IL_0019:  ldc.i4.1
+    IL_001a:  add
+    IL_001b:  stloc.1
+    IL_001c:  ldloc.1
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.1
+    IL_001f:  add
+    IL_0020:  bne.un.s   IL_0008
+
+    IL_0022:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M$fsx
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable03.fsx.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable03.fsx.il.net472.release.bsl
new file mode 100644
index 00000000000..30f24778b50
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable03.fsx.il.net472.release.bsl
@@ -0,0 +1,108 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  loop3(int32 a,
+                                    int32 N) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0029
+
+    IL_0008:  ldstr      "aaa"
+    IL_000d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_0012:  stloc.2
+    IL_0013:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_0018:  ldloc.2
+    IL_0019:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_001e:  pop
+    IL_001f:  ldloc.1
+    IL_0020:  ldc.i4.1
+    IL_0021:  add
+    IL_0022:  stloc.1
+    IL_0023:  ldloc.1
+    IL_0024:  ldloc.0
+    IL_0025:  ldc.i4.1
+    IL_0026:  add
+    IL_0027:  bne.un.s   IL_0008
+
+    IL_0029:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M$fsx
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable03.fsx.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable03.fsx.il.netcore.debug.bsl
new file mode 100644
index 00000000000..c580ba49eec
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable03.fsx.il.netcore.debug.bsl
@@ -0,0 +1,98 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  loop3(int32 a,
+                                    int32 N) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0022
+
+    IL_0008:  ldstr      "aaa"
+    IL_000d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_0012:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0017:  pop
+    IL_0018:  ldloc.1
+    IL_0019:  ldc.i4.1
+    IL_001a:  add
+    IL_001b:  stloc.1
+    IL_001c:  ldloc.1
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.1
+    IL_001f:  add
+    IL_0020:  bne.un.s   IL_0008
+
+    IL_0022:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M$fsx
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable03.fsx.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable03.fsx.il.netcore.release.bsl
new file mode 100644
index 00000000000..e916dd0c946
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NoIEnumerable03.fsx.il.netcore.release.bsl
@@ -0,0 +1,108 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  loop3(int32 a,
+                                    int32 N) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0029
+
+    IL_0008:  ldstr      "aaa"
+    IL_000d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_0012:  stloc.2
+    IL_0013:  call       class [netstandard]System.IO.TextWriter [netstandard]System.Console::get_Out()
+    IL_0018:  ldloc.2
+    IL_0019:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.PrintfModule::PrintFormatLineToTextWriter<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [runtime]System.IO.TextWriter,
+                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_001e:  pop
+    IL_001f:  ldloc.1
+    IL_0020:  ldc.i4.1
+    IL_0021:  add
+    IL_0022:  stloc.1
+    IL_0023:  ldloc.1
+    IL_0024:  ldloc.0
+    IL_0025:  ldc.i4.1
+    IL_0026:  add
+    IL_0027:  bne.un.s   IL_0008
+
+    IL_0029:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M$fsx
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd01.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd01.fs
new file mode 100644
index 00000000000..9288143b4de
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd01.fs
@@ -0,0 +1,12 @@
+// #Regression #CodeGen #Optimizations #ControlFlow 
+// Regression test for FSHARP1.0:5306
+// Bad codegen while optimizing for-loops with non-trivial branching and binding in end
+//<Expects status="success"></Expects>
+
+let r = Array.create 8 1
+let w = Array.create 5 2
+
+for j = 0 to (min r.Length w.Length) - 1 do
+   r.[j] <- r.[j] + w.[j]
+
+(if r.[0] = 3 then 0 else 1) |> exit
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd01.fs.il.bsl
new file mode 100644
index 00000000000..e8db92a48a8
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd01.fs.il.bsl
@@ -0,0 +1,195 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly int32[] r@6
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32[] w@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32[] get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::r@6
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32[] get_w() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::w@7
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             int32 V_3)
+    IL_0000:  ldc.i4.8
+    IL_0001:  ldc.i4.1
+    IL_0002:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0007:  stsfld     int32[] assembly::r@6
+    IL_000c:  ldc.i4.5
+    IL_000d:  ldc.i4.2
+    IL_000e:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0013:  stsfld     int32[] assembly::w@7
+    IL_0018:  ldc.i4.0
+    IL_0019:  stloc.1
+    IL_001a:  call       int32[] assembly::get_r()
+    IL_001f:  ldlen
+    IL_0020:  conv.i4
+    IL_0021:  stloc.2
+    IL_0022:  call       int32[] assembly::get_w()
+    IL_0027:  ldlen
+    IL_0028:  conv.i4
+    IL_0029:  stloc.3
+    IL_002a:  ldloc.2
+    IL_002b:  ldloc.3
+    IL_002c:  bge.s      IL_0032
+
+    IL_002e:  ldloc.2
+    IL_002f:  nop
+    IL_0030:  br.s       IL_0034
+
+    IL_0032:  ldloc.3
+    IL_0033:  nop
+    IL_0034:  ldc.i4.1
+    IL_0035:  sub
+    IL_0036:  stloc.0
+    IL_0037:  ldloc.0
+    IL_0038:  ldloc.1
+    IL_0039:  blt.s      IL_0067
+
+    IL_003b:  call       int32[] assembly::get_r()
+    IL_0040:  ldloc.1
+    IL_0041:  call       int32[] assembly::get_r()
+    IL_0046:  ldloc.1
+    IL_0047:  ldelem     [runtime]System.Int32
+    IL_004c:  call       int32[] assembly::get_w()
+    IL_0051:  ldloc.1
+    IL_0052:  ldelem     [runtime]System.Int32
+    IL_0057:  add
+    IL_0058:  stelem     [runtime]System.Int32
+    IL_005d:  ldloc.1
+    IL_005e:  ldc.i4.1
+    IL_005f:  add
+    IL_0060:  stloc.1
+    IL_0061:  ldloc.1
+    IL_0062:  ldloc.0
+    IL_0063:  ldc.i4.1
+    IL_0064:  add
+    IL_0065:  bne.un.s   IL_003b
+
+    IL_0067:  nop
+    IL_0068:  nop
+    IL_0069:  call       int32[] assembly::get_r()
+    IL_006e:  ldc.i4.0
+    IL_006f:  ldelem     [runtime]System.Int32
+    IL_0074:  ldc.i4.3
+    IL_0075:  bne.un.s   IL_007b
+
+    IL_0077:  ldc.i4.0
+    IL_0078:  nop
+    IL_0079:  br.s       IL_007d
+
+    IL_007b:  ldc.i4.1
+    IL_007c:  nop
+    IL_007d:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_0082:  pop
+    IL_0083:  ret
+  } 
+
+  .property int32[] r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_r()
+  } 
+  .property int32[] w()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_w()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd01.fs.opt.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd01.fs.opt.il.bsl
new file mode 100644
index 00000000000..e8db92a48a8
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd01.fs.opt.il.bsl
@@ -0,0 +1,195 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly int32[] r@6
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32[] w@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32[] get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::r@6
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32[] get_w() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::w@7
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             int32 V_3)
+    IL_0000:  ldc.i4.8
+    IL_0001:  ldc.i4.1
+    IL_0002:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0007:  stsfld     int32[] assembly::r@6
+    IL_000c:  ldc.i4.5
+    IL_000d:  ldc.i4.2
+    IL_000e:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0013:  stsfld     int32[] assembly::w@7
+    IL_0018:  ldc.i4.0
+    IL_0019:  stloc.1
+    IL_001a:  call       int32[] assembly::get_r()
+    IL_001f:  ldlen
+    IL_0020:  conv.i4
+    IL_0021:  stloc.2
+    IL_0022:  call       int32[] assembly::get_w()
+    IL_0027:  ldlen
+    IL_0028:  conv.i4
+    IL_0029:  stloc.3
+    IL_002a:  ldloc.2
+    IL_002b:  ldloc.3
+    IL_002c:  bge.s      IL_0032
+
+    IL_002e:  ldloc.2
+    IL_002f:  nop
+    IL_0030:  br.s       IL_0034
+
+    IL_0032:  ldloc.3
+    IL_0033:  nop
+    IL_0034:  ldc.i4.1
+    IL_0035:  sub
+    IL_0036:  stloc.0
+    IL_0037:  ldloc.0
+    IL_0038:  ldloc.1
+    IL_0039:  blt.s      IL_0067
+
+    IL_003b:  call       int32[] assembly::get_r()
+    IL_0040:  ldloc.1
+    IL_0041:  call       int32[] assembly::get_r()
+    IL_0046:  ldloc.1
+    IL_0047:  ldelem     [runtime]System.Int32
+    IL_004c:  call       int32[] assembly::get_w()
+    IL_0051:  ldloc.1
+    IL_0052:  ldelem     [runtime]System.Int32
+    IL_0057:  add
+    IL_0058:  stelem     [runtime]System.Int32
+    IL_005d:  ldloc.1
+    IL_005e:  ldc.i4.1
+    IL_005f:  add
+    IL_0060:  stloc.1
+    IL_0061:  ldloc.1
+    IL_0062:  ldloc.0
+    IL_0063:  ldc.i4.1
+    IL_0064:  add
+    IL_0065:  bne.un.s   IL_003b
+
+    IL_0067:  nop
+    IL_0068:  nop
+    IL_0069:  call       int32[] assembly::get_r()
+    IL_006e:  ldc.i4.0
+    IL_006f:  ldelem     [runtime]System.Int32
+    IL_0074:  ldc.i4.3
+    IL_0075:  bne.un.s   IL_007b
+
+    IL_0077:  ldc.i4.0
+    IL_0078:  nop
+    IL_0079:  br.s       IL_007d
+
+    IL_007b:  ldc.i4.1
+    IL_007c:  nop
+    IL_007d:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_0082:  pop
+    IL_0083:  ret
+  } 
+
+  .property int32[] r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_r()
+  } 
+  .property int32[] w()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_w()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd02.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd02.fs
new file mode 100644
index 00000000000..9f976b52b52
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd02.fs
@@ -0,0 +1,12 @@
+// #Regression #CodeGen #Optimizations #ControlFlow 
+// Regression test for FSHARP1.0:5306
+// Bad codegen while optimizing for-loops with non-trivial branching and binding in end
+//<Expects status="success"></Expects>
+
+let r = Array.create 8 1
+let w = Array.create 5 2
+
+
+for j = (min r.Length w.Length) - 1 downto 0 do
+   r.[j] <- r.[j] + w.[j]
+(if r.[0] = 3 then 0 else 1) |> exit
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd02.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd02.fs.il.bsl
new file mode 100644
index 00000000000..cfa46cc2c6d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd02.fs.il.bsl
@@ -0,0 +1,193 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly int32[] r@6
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32[] w@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32[] get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::r@6
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32[] get_w() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::w@7
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldc.i4.8
+    IL_0001:  ldc.i4.1
+    IL_0002:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0007:  stsfld     int32[] assembly::r@6
+    IL_000c:  ldc.i4.5
+    IL_000d:  ldc.i4.2
+    IL_000e:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0013:  stsfld     int32[] assembly::w@7
+    IL_0018:  call       int32[] assembly::get_r()
+    IL_001d:  ldlen
+    IL_001e:  conv.i4
+    IL_001f:  stloc.0
+    IL_0020:  call       int32[] assembly::get_w()
+    IL_0025:  ldlen
+    IL_0026:  conv.i4
+    IL_0027:  stloc.1
+    IL_0028:  ldloc.0
+    IL_0029:  ldloc.1
+    IL_002a:  bge.s      IL_0030
+
+    IL_002c:  ldloc.0
+    IL_002d:  nop
+    IL_002e:  br.s       IL_0032
+
+    IL_0030:  ldloc.1
+    IL_0031:  nop
+    IL_0032:  ldc.i4.1
+    IL_0033:  sub
+    IL_0034:  stloc.1
+    IL_0035:  ldc.i4.0
+    IL_0036:  stloc.0
+    IL_0037:  ldloc.0
+    IL_0038:  ldloc.1
+    IL_0039:  bgt.s      IL_0067
+
+    IL_003b:  call       int32[] assembly::get_r()
+    IL_0040:  ldloc.1
+    IL_0041:  call       int32[] assembly::get_r()
+    IL_0046:  ldloc.1
+    IL_0047:  ldelem     [runtime]System.Int32
+    IL_004c:  call       int32[] assembly::get_w()
+    IL_0051:  ldloc.1
+    IL_0052:  ldelem     [runtime]System.Int32
+    IL_0057:  add
+    IL_0058:  stelem     [runtime]System.Int32
+    IL_005d:  ldloc.1
+    IL_005e:  ldc.i4.1
+    IL_005f:  sub
+    IL_0060:  stloc.1
+    IL_0061:  ldloc.1
+    IL_0062:  ldloc.0
+    IL_0063:  ldc.i4.1
+    IL_0064:  sub
+    IL_0065:  bne.un.s   IL_003b
+
+    IL_0067:  nop
+    IL_0068:  nop
+    IL_0069:  call       int32[] assembly::get_r()
+    IL_006e:  ldc.i4.0
+    IL_006f:  ldelem     [runtime]System.Int32
+    IL_0074:  ldc.i4.3
+    IL_0075:  bne.un.s   IL_007b
+
+    IL_0077:  ldc.i4.0
+    IL_0078:  nop
+    IL_0079:  br.s       IL_007d
+
+    IL_007b:  ldc.i4.1
+    IL_007c:  nop
+    IL_007d:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_0082:  pop
+    IL_0083:  ret
+  } 
+
+  .property int32[] r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_r()
+  } 
+  .property int32[] w()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_w()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd02.fs.opt.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd02.fs.opt.il.bsl
new file mode 100644
index 00000000000..cfa46cc2c6d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd02.fs.opt.il.bsl
@@ -0,0 +1,193 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly int32[] r@6
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32[] w@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32[] get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::r@6
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32[] get_w() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::w@7
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldc.i4.8
+    IL_0001:  ldc.i4.1
+    IL_0002:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0007:  stsfld     int32[] assembly::r@6
+    IL_000c:  ldc.i4.5
+    IL_000d:  ldc.i4.2
+    IL_000e:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0013:  stsfld     int32[] assembly::w@7
+    IL_0018:  call       int32[] assembly::get_r()
+    IL_001d:  ldlen
+    IL_001e:  conv.i4
+    IL_001f:  stloc.0
+    IL_0020:  call       int32[] assembly::get_w()
+    IL_0025:  ldlen
+    IL_0026:  conv.i4
+    IL_0027:  stloc.1
+    IL_0028:  ldloc.0
+    IL_0029:  ldloc.1
+    IL_002a:  bge.s      IL_0030
+
+    IL_002c:  ldloc.0
+    IL_002d:  nop
+    IL_002e:  br.s       IL_0032
+
+    IL_0030:  ldloc.1
+    IL_0031:  nop
+    IL_0032:  ldc.i4.1
+    IL_0033:  sub
+    IL_0034:  stloc.1
+    IL_0035:  ldc.i4.0
+    IL_0036:  stloc.0
+    IL_0037:  ldloc.0
+    IL_0038:  ldloc.1
+    IL_0039:  bgt.s      IL_0067
+
+    IL_003b:  call       int32[] assembly::get_r()
+    IL_0040:  ldloc.1
+    IL_0041:  call       int32[] assembly::get_r()
+    IL_0046:  ldloc.1
+    IL_0047:  ldelem     [runtime]System.Int32
+    IL_004c:  call       int32[] assembly::get_w()
+    IL_0051:  ldloc.1
+    IL_0052:  ldelem     [runtime]System.Int32
+    IL_0057:  add
+    IL_0058:  stelem     [runtime]System.Int32
+    IL_005d:  ldloc.1
+    IL_005e:  ldc.i4.1
+    IL_005f:  sub
+    IL_0060:  stloc.1
+    IL_0061:  ldloc.1
+    IL_0062:  ldloc.0
+    IL_0063:  ldc.i4.1
+    IL_0064:  sub
+    IL_0065:  bne.un.s   IL_003b
+
+    IL_0067:  nop
+    IL_0068:  nop
+    IL_0069:  call       int32[] assembly::get_r()
+    IL_006e:  ldc.i4.0
+    IL_006f:  ldelem     [runtime]System.Int32
+    IL_0074:  ldc.i4.3
+    IL_0075:  bne.un.s   IL_007b
+
+    IL_0077:  ldc.i4.0
+    IL_0078:  nop
+    IL_0079:  br.s       IL_007d
+
+    IL_007b:  ldc.i4.1
+    IL_007c:  nop
+    IL_007d:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_0082:  pop
+    IL_0083:  ret
+  } 
+
+  .property int32[] r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_r()
+  } 
+  .property int32[] w()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_w()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd03.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd03.fs
new file mode 100644
index 00000000000..25e457f4509
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd03.fs
@@ -0,0 +1,11 @@
+// #Regression #CodeGen #Optimizations #ControlFlow 
+// Regression test for FSHARP1.0:5306
+// Bad codegen while optimizing for-loops with non-trivial branching and binding in end
+//<Expects status="success"></Expects>
+
+let r = Array.create 8 1
+let w = Array.create 5 2
+
+for j in [0 .. (min r.Length w.Length) - 1] do
+   r.[j] <- r.[j] + w.[j]
+(if r.[0] = 3 then 0 else 1) |> exit
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd03.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd03.fs.il.bsl
new file mode 100644
index 00000000000..475e4e35c66
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd03.fs.il.bsl
@@ -0,0 +1,281 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly int32[] r@6
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32[] w@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> current@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 e1@1
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 e2@1
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> next@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32[] get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::r@6
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32[] get_w() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::w@7
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_current@9() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::current@9
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static void set_current@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 'value') cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::current@9
+    IL_0006:  ret
+  } 
+
+  .method assembly specialname static int32 get_e1@1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::e1@1
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static int32 get_e2@1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::e2@1
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_next@9() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::next@9
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static void set_next@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 'value') cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::next@9
+    IL_0006:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  7
+    .locals init (int32 V_0)
+    IL_0000:  ldc.i4.8
+    IL_0001:  ldc.i4.1
+    IL_0002:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0007:  stsfld     int32[] assembly::r@6
+    IL_000c:  ldc.i4.5
+    IL_000d:  ldc.i4.2
+    IL_000e:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0013:  stsfld     int32[] assembly::w@7
+    IL_0018:  ldc.i4.0
+    IL_0019:  ldc.i4.1
+    IL_001a:  call       int32[] assembly::get_r()
+    IL_001f:  ldlen
+    IL_0020:  conv.i4
+    IL_0021:  stsfld     int32 assembly::e1@1
+    IL_0026:  call       int32[] assembly::get_w()
+    IL_002b:  ldlen
+    IL_002c:  conv.i4
+    IL_002d:  stsfld     int32 assembly::e2@1
+    IL_0032:  call       int32 assembly::get_e1@1()
+    IL_0037:  call       int32 assembly::get_e2@1()
+    IL_003c:  bge.s      IL_0046
+
+    IL_003e:  call       int32 assembly::get_e1@1()
+    IL_0043:  nop
+    IL_0044:  br.s       IL_004c
+
+    IL_0046:  call       int32 assembly::get_e2@1()
+    IL_004b:  nop
+    IL_004c:  ldc.i4.1
+    IL_004d:  sub
+    IL_004e:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                     int32,
+                                                                                                                                                                     int32)
+    IL_0053:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::CreateSequence<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0058:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_005d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::current@9
+    IL_0062:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_current@9()
+    IL_0067:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_006c:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::next@9
+    IL_0071:  br.s       IL_00b9
+
+    IL_0073:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_current@9()
+    IL_0078:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_007d:  stloc.0
+    IL_007e:  call       int32[] assembly::get_r()
+    IL_0083:  ldloc.0
+    IL_0084:  call       int32[] assembly::get_r()
+    IL_0089:  ldloc.0
+    IL_008a:  ldelem     [runtime]System.Int32
+    IL_008f:  call       int32[] assembly::get_w()
+    IL_0094:  ldloc.0
+    IL_0095:  ldelem     [runtime]System.Int32
+    IL_009a:  add
+    IL_009b:  stelem     [runtime]System.Int32
+    IL_00a0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_next@9()
+    IL_00a5:  call       void assembly::set_current@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    IL_00aa:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_current@9()
+    IL_00af:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_00b4:  call       void assembly::set_next@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    IL_00b9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_next@9()
+    IL_00be:  brtrue.s   IL_0073
+
+    IL_00c0:  nop
+    IL_00c1:  nop
+    IL_00c2:  call       int32[] assembly::get_r()
+    IL_00c7:  ldc.i4.0
+    IL_00c8:  ldelem     [runtime]System.Int32
+    IL_00cd:  ldc.i4.3
+    IL_00ce:  bne.un.s   IL_00d4
+
+    IL_00d0:  ldc.i4.0
+    IL_00d1:  nop
+    IL_00d2:  br.s       IL_00d6
+
+    IL_00d4:  ldc.i4.1
+    IL_00d5:  nop
+    IL_00d6:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_00db:  pop
+    IL_00dc:  ret
+  } 
+
+  .property int32[] r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_r()
+  } 
+  .property int32[] w()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_w()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          current@9()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .set void assembly::set_current@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_current@9()
+  } 
+  .property int32 e1@1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_e1@1()
+  } 
+  .property int32 e2@1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_e2@1()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          next@9()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .set void assembly::set_next@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_next@9()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd03.fs.opt.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd03.fs.opt.il.bsl
new file mode 100644
index 00000000000..475e4e35c66
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd03.fs.opt.il.bsl
@@ -0,0 +1,281 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly int32[] r@6
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32[] w@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> current@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 e1@1
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 e2@1
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> next@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32[] get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::r@6
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32[] get_w() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::w@7
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_current@9() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::current@9
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static void set_current@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 'value') cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::current@9
+    IL_0006:  ret
+  } 
+
+  .method assembly specialname static int32 get_e1@1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::e1@1
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static int32 get_e2@1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::e2@1
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_next@9() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::next@9
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static void set_next@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 'value') cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::next@9
+    IL_0006:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  7
+    .locals init (int32 V_0)
+    IL_0000:  ldc.i4.8
+    IL_0001:  ldc.i4.1
+    IL_0002:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0007:  stsfld     int32[] assembly::r@6
+    IL_000c:  ldc.i4.5
+    IL_000d:  ldc.i4.2
+    IL_000e:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0013:  stsfld     int32[] assembly::w@7
+    IL_0018:  ldc.i4.0
+    IL_0019:  ldc.i4.1
+    IL_001a:  call       int32[] assembly::get_r()
+    IL_001f:  ldlen
+    IL_0020:  conv.i4
+    IL_0021:  stsfld     int32 assembly::e1@1
+    IL_0026:  call       int32[] assembly::get_w()
+    IL_002b:  ldlen
+    IL_002c:  conv.i4
+    IL_002d:  stsfld     int32 assembly::e2@1
+    IL_0032:  call       int32 assembly::get_e1@1()
+    IL_0037:  call       int32 assembly::get_e2@1()
+    IL_003c:  bge.s      IL_0046
+
+    IL_003e:  call       int32 assembly::get_e1@1()
+    IL_0043:  nop
+    IL_0044:  br.s       IL_004c
+
+    IL_0046:  call       int32 assembly::get_e2@1()
+    IL_004b:  nop
+    IL_004c:  ldc.i4.1
+    IL_004d:  sub
+    IL_004e:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                     int32,
+                                                                                                                                                                     int32)
+    IL_0053:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::CreateSequence<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0058:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_005d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::current@9
+    IL_0062:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_current@9()
+    IL_0067:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_006c:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::next@9
+    IL_0071:  br.s       IL_00b9
+
+    IL_0073:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_current@9()
+    IL_0078:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_007d:  stloc.0
+    IL_007e:  call       int32[] assembly::get_r()
+    IL_0083:  ldloc.0
+    IL_0084:  call       int32[] assembly::get_r()
+    IL_0089:  ldloc.0
+    IL_008a:  ldelem     [runtime]System.Int32
+    IL_008f:  call       int32[] assembly::get_w()
+    IL_0094:  ldloc.0
+    IL_0095:  ldelem     [runtime]System.Int32
+    IL_009a:  add
+    IL_009b:  stelem     [runtime]System.Int32
+    IL_00a0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_next@9()
+    IL_00a5:  call       void assembly::set_current@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    IL_00aa:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_current@9()
+    IL_00af:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_00b4:  call       void assembly::set_next@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    IL_00b9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_next@9()
+    IL_00be:  brtrue.s   IL_0073
+
+    IL_00c0:  nop
+    IL_00c1:  nop
+    IL_00c2:  call       int32[] assembly::get_r()
+    IL_00c7:  ldc.i4.0
+    IL_00c8:  ldelem     [runtime]System.Int32
+    IL_00cd:  ldc.i4.3
+    IL_00ce:  bne.un.s   IL_00d4
+
+    IL_00d0:  ldc.i4.0
+    IL_00d1:  nop
+    IL_00d2:  br.s       IL_00d6
+
+    IL_00d4:  ldc.i4.1
+    IL_00d5:  nop
+    IL_00d6:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_00db:  pop
+    IL_00dc:  ret
+  } 
+
+  .property int32[] r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_r()
+  } 
+  .property int32[] w()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_w()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          current@9()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .set void assembly::set_current@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_current@9()
+  } 
+  .property int32 e1@1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_e1@1()
+  } 
+  .property int32 e2@1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_e2@1()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          next@9()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .set void assembly::set_next@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_next@9()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd04.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd04.fs
new file mode 100644
index 00000000000..57bf33efac2
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd04.fs
@@ -0,0 +1,11 @@
+// #Regression #CodeGen #Optimizations #ControlFlow 
+// Regression test for FSHARP1.0:5306
+// Bad codegen while optimizing for-loops with non-trivial branching and binding in end
+//<Expects status="success"></Expects>
+
+let r = Array.create 8 1
+let w = Array.create 5 2
+
+for j in [(min r.Length w.Length) - 1 .. -1 .. 0] do
+   r.[j] <- r.[j] + w.[j]
+(if r.[0] = 3 then 0 else 1) |> exit
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd04.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd04.fs.il.bsl
new file mode 100644
index 00000000000..07b8377812d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd04.fs.il.bsl
@@ -0,0 +1,281 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly int32[] r@6
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32[] w@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> current@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 e1@1
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 e2@1
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> next@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32[] get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::r@6
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32[] get_w() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::w@7
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_current@9() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::current@9
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static void set_current@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 'value') cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::current@9
+    IL_0006:  ret
+  } 
+
+  .method assembly specialname static int32 get_e1@1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::e1@1
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static int32 get_e2@1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::e2@1
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_next@9() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::next@9
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static void set_next@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 'value') cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::next@9
+    IL_0006:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  7
+    .locals init (int32 V_0)
+    IL_0000:  ldc.i4.8
+    IL_0001:  ldc.i4.1
+    IL_0002:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0007:  stsfld     int32[] assembly::r@6
+    IL_000c:  ldc.i4.5
+    IL_000d:  ldc.i4.2
+    IL_000e:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0013:  stsfld     int32[] assembly::w@7
+    IL_0018:  call       int32[] assembly::get_r()
+    IL_001d:  ldlen
+    IL_001e:  conv.i4
+    IL_001f:  stsfld     int32 assembly::e1@1
+    IL_0024:  call       int32[] assembly::get_w()
+    IL_0029:  ldlen
+    IL_002a:  conv.i4
+    IL_002b:  stsfld     int32 assembly::e2@1
+    IL_0030:  call       int32 assembly::get_e1@1()
+    IL_0035:  call       int32 assembly::get_e2@1()
+    IL_003a:  bge.s      IL_0044
+
+    IL_003c:  call       int32 assembly::get_e1@1()
+    IL_0041:  nop
+    IL_0042:  br.s       IL_004a
+
+    IL_0044:  call       int32 assembly::get_e2@1()
+    IL_0049:  nop
+    IL_004a:  ldc.i4.1
+    IL_004b:  sub
+    IL_004c:  ldc.i4.m1
+    IL_004d:  ldc.i4.0
+    IL_004e:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                     int32,
+                                                                                                                                                                     int32)
+    IL_0053:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::CreateSequence<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0058:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_005d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::current@9
+    IL_0062:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_current@9()
+    IL_0067:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_006c:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::next@9
+    IL_0071:  br.s       IL_00b9
+
+    IL_0073:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_current@9()
+    IL_0078:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_007d:  stloc.0
+    IL_007e:  call       int32[] assembly::get_r()
+    IL_0083:  ldloc.0
+    IL_0084:  call       int32[] assembly::get_r()
+    IL_0089:  ldloc.0
+    IL_008a:  ldelem     [runtime]System.Int32
+    IL_008f:  call       int32[] assembly::get_w()
+    IL_0094:  ldloc.0
+    IL_0095:  ldelem     [runtime]System.Int32
+    IL_009a:  add
+    IL_009b:  stelem     [runtime]System.Int32
+    IL_00a0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_next@9()
+    IL_00a5:  call       void assembly::set_current@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    IL_00aa:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_current@9()
+    IL_00af:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_00b4:  call       void assembly::set_next@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    IL_00b9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_next@9()
+    IL_00be:  brtrue.s   IL_0073
+
+    IL_00c0:  nop
+    IL_00c1:  nop
+    IL_00c2:  call       int32[] assembly::get_r()
+    IL_00c7:  ldc.i4.0
+    IL_00c8:  ldelem     [runtime]System.Int32
+    IL_00cd:  ldc.i4.3
+    IL_00ce:  bne.un.s   IL_00d4
+
+    IL_00d0:  ldc.i4.0
+    IL_00d1:  nop
+    IL_00d2:  br.s       IL_00d6
+
+    IL_00d4:  ldc.i4.1
+    IL_00d5:  nop
+    IL_00d6:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_00db:  pop
+    IL_00dc:  ret
+  } 
+
+  .property int32[] r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_r()
+  } 
+  .property int32[] w()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_w()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          current@9()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .set void assembly::set_current@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_current@9()
+  } 
+  .property int32 e1@1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_e1@1()
+  } 
+  .property int32 e2@1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_e2@1()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          next@9()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .set void assembly::set_next@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_next@9()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd04.fs.opt.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd04.fs.opt.il.bsl
new file mode 100644
index 00000000000..07b8377812d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd04.fs.opt.il.bsl
@@ -0,0 +1,281 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly int32[] r@6
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32[] w@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> current@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 e1@1
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 e2@1
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> next@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32[] get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::r@6
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32[] get_w() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::w@7
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_current@9() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::current@9
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static void set_current@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 'value') cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::current@9
+    IL_0006:  ret
+  } 
+
+  .method assembly specialname static int32 get_e1@1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::e1@1
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static int32 get_e2@1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::e2@1
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_next@9() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::next@9
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static void set_next@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 'value') cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::next@9
+    IL_0006:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  7
+    .locals init (int32 V_0)
+    IL_0000:  ldc.i4.8
+    IL_0001:  ldc.i4.1
+    IL_0002:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0007:  stsfld     int32[] assembly::r@6
+    IL_000c:  ldc.i4.5
+    IL_000d:  ldc.i4.2
+    IL_000e:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0013:  stsfld     int32[] assembly::w@7
+    IL_0018:  call       int32[] assembly::get_r()
+    IL_001d:  ldlen
+    IL_001e:  conv.i4
+    IL_001f:  stsfld     int32 assembly::e1@1
+    IL_0024:  call       int32[] assembly::get_w()
+    IL_0029:  ldlen
+    IL_002a:  conv.i4
+    IL_002b:  stsfld     int32 assembly::e2@1
+    IL_0030:  call       int32 assembly::get_e1@1()
+    IL_0035:  call       int32 assembly::get_e2@1()
+    IL_003a:  bge.s      IL_0044
+
+    IL_003c:  call       int32 assembly::get_e1@1()
+    IL_0041:  nop
+    IL_0042:  br.s       IL_004a
+
+    IL_0044:  call       int32 assembly::get_e2@1()
+    IL_0049:  nop
+    IL_004a:  ldc.i4.1
+    IL_004b:  sub
+    IL_004c:  ldc.i4.m1
+    IL_004d:  ldc.i4.0
+    IL_004e:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                     int32,
+                                                                                                                                                                     int32)
+    IL_0053:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::CreateSequence<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0058:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_005d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::current@9
+    IL_0062:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_current@9()
+    IL_0067:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_006c:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::next@9
+    IL_0071:  br.s       IL_00b9
+
+    IL_0073:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_current@9()
+    IL_0078:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_007d:  stloc.0
+    IL_007e:  call       int32[] assembly::get_r()
+    IL_0083:  ldloc.0
+    IL_0084:  call       int32[] assembly::get_r()
+    IL_0089:  ldloc.0
+    IL_008a:  ldelem     [runtime]System.Int32
+    IL_008f:  call       int32[] assembly::get_w()
+    IL_0094:  ldloc.0
+    IL_0095:  ldelem     [runtime]System.Int32
+    IL_009a:  add
+    IL_009b:  stelem     [runtime]System.Int32
+    IL_00a0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_next@9()
+    IL_00a5:  call       void assembly::set_current@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    IL_00aa:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_current@9()
+    IL_00af:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_00b4:  call       void assembly::set_next@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    IL_00b9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_next@9()
+    IL_00be:  brtrue.s   IL_0073
+
+    IL_00c0:  nop
+    IL_00c1:  nop
+    IL_00c2:  call       int32[] assembly::get_r()
+    IL_00c7:  ldc.i4.0
+    IL_00c8:  ldelem     [runtime]System.Int32
+    IL_00cd:  ldc.i4.3
+    IL_00ce:  bne.un.s   IL_00d4
+
+    IL_00d0:  ldc.i4.0
+    IL_00d1:  nop
+    IL_00d2:  br.s       IL_00d6
+
+    IL_00d4:  ldc.i4.1
+    IL_00d5:  nop
+    IL_00d6:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_00db:  pop
+    IL_00dc:  ret
+  } 
+
+  .property int32[] r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_r()
+  } 
+  .property int32[] w()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_w()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          current@9()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .set void assembly::set_current@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_current@9()
+  } 
+  .property int32 e1@1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_e1@1()
+  } 
+  .property int32 e2@1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_e2@1()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          next@9()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .set void assembly::set_next@9(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_next@9()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd05.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd05.fs
new file mode 100644
index 00000000000..1c3e67958e4
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd05.fs
@@ -0,0 +1,12 @@
+// #Regression #CodeGen #Optimizations #ControlFlow 
+// Regression test for FSHARP1.0:5306
+// Bad codegen while optimizing for-loops with non-trivial branching and binding in end
+//<Expects status="success"></Expects>
+
+let r = Array.create 8 1
+let w = Array.create 5 2
+
+for k = 0 to (min r.Length w.Length) - 1 do
+    for j = 0 to (min r.Length w.Length) - 1 do
+        r.[j] <- r.[j] + w.[j]
+(if r.[0] = 11 then 0 else 1) |> exit
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd05.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd05.fs.il.bsl
new file mode 100644
index 00000000000..89d1309f7bd
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd05.fs.il.bsl
@@ -0,0 +1,234 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly int32[] r@6
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32[] w@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32[] get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::r@6
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32[] get_w() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::w@7
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             int32 V_3,
+             int32 V_4,
+             int32 V_5)
+    IL_0000:  ldc.i4.8
+    IL_0001:  ldc.i4.1
+    IL_0002:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0007:  stsfld     int32[] assembly::r@6
+    IL_000c:  ldc.i4.5
+    IL_000d:  ldc.i4.2
+    IL_000e:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0013:  stsfld     int32[] assembly::w@7
+    IL_0018:  ldc.i4.0
+    IL_0019:  stloc.1
+    IL_001a:  call       int32[] assembly::get_r()
+    IL_001f:  ldlen
+    IL_0020:  conv.i4
+    IL_0021:  stloc.2
+    IL_0022:  call       int32[] assembly::get_w()
+    IL_0027:  ldlen
+    IL_0028:  conv.i4
+    IL_0029:  stloc.3
+    IL_002a:  ldloc.2
+    IL_002b:  ldloc.3
+    IL_002c:  bge.s      IL_0032
+
+    IL_002e:  ldloc.2
+    IL_002f:  nop
+    IL_0030:  br.s       IL_0034
+
+    IL_0032:  ldloc.3
+    IL_0033:  nop
+    IL_0034:  ldc.i4.1
+    IL_0035:  sub
+    IL_0036:  stloc.0
+    IL_0037:  ldloc.0
+    IL_0038:  ldloc.1
+    IL_0039:  blt.s      IL_009a
+
+    IL_003b:  ldc.i4.0
+    IL_003c:  stloc.3
+    IL_003d:  call       int32[] assembly::get_r()
+    IL_0042:  ldlen
+    IL_0043:  conv.i4
+    IL_0044:  stloc.s    V_4
+    IL_0046:  call       int32[] assembly::get_w()
+    IL_004b:  ldlen
+    IL_004c:  conv.i4
+    IL_004d:  stloc.s    V_5
+    IL_004f:  ldloc.s    V_4
+    IL_0051:  ldloc.s    V_5
+    IL_0053:  bge.s      IL_005a
+
+    IL_0055:  ldloc.s    V_4
+    IL_0057:  nop
+    IL_0058:  br.s       IL_005d
+
+    IL_005a:  ldloc.s    V_5
+    IL_005c:  nop
+    IL_005d:  ldc.i4.1
+    IL_005e:  sub
+    IL_005f:  stloc.2
+    IL_0060:  ldloc.2
+    IL_0061:  ldloc.3
+    IL_0062:  blt.s      IL_0090
+
+    IL_0064:  call       int32[] assembly::get_r()
+    IL_0069:  ldloc.3
+    IL_006a:  call       int32[] assembly::get_r()
+    IL_006f:  ldloc.3
+    IL_0070:  ldelem     [runtime]System.Int32
+    IL_0075:  call       int32[] assembly::get_w()
+    IL_007a:  ldloc.3
+    IL_007b:  ldelem     [runtime]System.Int32
+    IL_0080:  add
+    IL_0081:  stelem     [runtime]System.Int32
+    IL_0086:  ldloc.3
+    IL_0087:  ldc.i4.1
+    IL_0088:  add
+    IL_0089:  stloc.3
+    IL_008a:  ldloc.3
+    IL_008b:  ldloc.2
+    IL_008c:  ldc.i4.1
+    IL_008d:  add
+    IL_008e:  bne.un.s   IL_0064
+
+    IL_0090:  ldloc.1
+    IL_0091:  ldc.i4.1
+    IL_0092:  add
+    IL_0093:  stloc.1
+    IL_0094:  ldloc.1
+    IL_0095:  ldloc.0
+    IL_0096:  ldc.i4.1
+    IL_0097:  add
+    IL_0098:  bne.un.s   IL_003b
+
+    IL_009a:  nop
+    IL_009b:  nop
+    IL_009c:  call       int32[] assembly::get_r()
+    IL_00a1:  ldc.i4.0
+    IL_00a2:  ldelem     [runtime]System.Int32
+    IL_00a7:  ldc.i4.s   11
+    IL_00a9:  bne.un.s   IL_00af
+
+    IL_00ab:  ldc.i4.0
+    IL_00ac:  nop
+    IL_00ad:  br.s       IL_00b1
+
+    IL_00af:  ldc.i4.1
+    IL_00b0:  nop
+    IL_00b1:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_00b6:  pop
+    IL_00b7:  ret
+  } 
+
+  .property int32[] r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_r()
+  } 
+  .property int32[] w()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_w()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd05.fs.opt.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd05.fs.opt.il.bsl
new file mode 100644
index 00000000000..89d1309f7bd
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/NonTrivialBranchingBindingInEnd05.fs.opt.il.bsl
@@ -0,0 +1,234 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly int32[] r@6
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32[] w@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32[] get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::r@6
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32[] get_w() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::w@7
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             int32 V_1,
+             int32 V_2,
+             int32 V_3,
+             int32 V_4,
+             int32 V_5)
+    IL_0000:  ldc.i4.8
+    IL_0001:  ldc.i4.1
+    IL_0002:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0007:  stsfld     int32[] assembly::r@6
+    IL_000c:  ldc.i4.5
+    IL_000d:  ldc.i4.2
+    IL_000e:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<int32>(int32,
+                                                                                                    !!0)
+    IL_0013:  stsfld     int32[] assembly::w@7
+    IL_0018:  ldc.i4.0
+    IL_0019:  stloc.1
+    IL_001a:  call       int32[] assembly::get_r()
+    IL_001f:  ldlen
+    IL_0020:  conv.i4
+    IL_0021:  stloc.2
+    IL_0022:  call       int32[] assembly::get_w()
+    IL_0027:  ldlen
+    IL_0028:  conv.i4
+    IL_0029:  stloc.3
+    IL_002a:  ldloc.2
+    IL_002b:  ldloc.3
+    IL_002c:  bge.s      IL_0032
+
+    IL_002e:  ldloc.2
+    IL_002f:  nop
+    IL_0030:  br.s       IL_0034
+
+    IL_0032:  ldloc.3
+    IL_0033:  nop
+    IL_0034:  ldc.i4.1
+    IL_0035:  sub
+    IL_0036:  stloc.0
+    IL_0037:  ldloc.0
+    IL_0038:  ldloc.1
+    IL_0039:  blt.s      IL_009a
+
+    IL_003b:  ldc.i4.0
+    IL_003c:  stloc.3
+    IL_003d:  call       int32[] assembly::get_r()
+    IL_0042:  ldlen
+    IL_0043:  conv.i4
+    IL_0044:  stloc.s    V_4
+    IL_0046:  call       int32[] assembly::get_w()
+    IL_004b:  ldlen
+    IL_004c:  conv.i4
+    IL_004d:  stloc.s    V_5
+    IL_004f:  ldloc.s    V_4
+    IL_0051:  ldloc.s    V_5
+    IL_0053:  bge.s      IL_005a
+
+    IL_0055:  ldloc.s    V_4
+    IL_0057:  nop
+    IL_0058:  br.s       IL_005d
+
+    IL_005a:  ldloc.s    V_5
+    IL_005c:  nop
+    IL_005d:  ldc.i4.1
+    IL_005e:  sub
+    IL_005f:  stloc.2
+    IL_0060:  ldloc.2
+    IL_0061:  ldloc.3
+    IL_0062:  blt.s      IL_0090
+
+    IL_0064:  call       int32[] assembly::get_r()
+    IL_0069:  ldloc.3
+    IL_006a:  call       int32[] assembly::get_r()
+    IL_006f:  ldloc.3
+    IL_0070:  ldelem     [runtime]System.Int32
+    IL_0075:  call       int32[] assembly::get_w()
+    IL_007a:  ldloc.3
+    IL_007b:  ldelem     [runtime]System.Int32
+    IL_0080:  add
+    IL_0081:  stelem     [runtime]System.Int32
+    IL_0086:  ldloc.3
+    IL_0087:  ldc.i4.1
+    IL_0088:  add
+    IL_0089:  stloc.3
+    IL_008a:  ldloc.3
+    IL_008b:  ldloc.2
+    IL_008c:  ldc.i4.1
+    IL_008d:  add
+    IL_008e:  bne.un.s   IL_0064
+
+    IL_0090:  ldloc.1
+    IL_0091:  ldc.i4.1
+    IL_0092:  add
+    IL_0093:  stloc.1
+    IL_0094:  ldloc.1
+    IL_0095:  ldloc.0
+    IL_0096:  ldc.i4.1
+    IL_0097:  add
+    IL_0098:  bne.un.s   IL_003b
+
+    IL_009a:  nop
+    IL_009b:  nop
+    IL_009c:  call       int32[] assembly::get_r()
+    IL_00a1:  ldc.i4.0
+    IL_00a2:  ldelem     [runtime]System.Int32
+    IL_00a7:  ldc.i4.s   11
+    IL_00a9:  bne.un.s   IL_00af
+
+    IL_00ab:  ldc.i4.0
+    IL_00ac:  nop
+    IL_00ad:  br.s       IL_00b1
+
+    IL_00af:  ldc.i4.1
+    IL_00b0:  nop
+    IL_00b1:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_00b6:  pop
+    IL_00b7:  ret
+  } 
+
+  .property int32[] r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_r()
+  } 
+  .property int32[] w()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_w()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ZeroToArrLength01.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ZeroToArrLength01.fs
new file mode 100644
index 00000000000..68f256b2add
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ZeroToArrLength01.fs
@@ -0,0 +1,7 @@
+// #Regression #CodeGen #Optimizations #ControlFlow #NoMono #ReqNOMT 
+//
+// Regression test for FSHARP1.0:4461
+module ZeroToArrLength01
+let f1(arr:int[]) = 
+    for i = 0 to arr.Length - 1 do 
+        arr.[i] <- i
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ZeroToArrLength01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ZeroToArrLength01.fs.il.bsl
new file mode 100644
index 00000000000..5152851ed95
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ZeroToArrLength01.fs.il.bsl
@@ -0,0 +1,91 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  f1(int32[] arr) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  br.s       IL_0010
+
+    IL_0004:  ldarg.0
+    IL_0005:  ldloc.0
+    IL_0006:  ldloc.0
+    IL_0007:  stelem     [runtime]System.Int32
+    IL_000c:  ldloc.0
+    IL_000d:  ldc.i4.1
+    IL_000e:  add
+    IL_000f:  stloc.0
+    IL_0010:  ldloc.0
+    IL_0011:  ldarg.0
+    IL_0012:  ldlen
+    IL_0013:  conv.i4
+    IL_0014:  blt.s      IL_0004
+
+    IL_0016:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ZeroToArrLength02.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ZeroToArrLength02.fs
new file mode 100644
index 00000000000..96ec6ca9cad
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ZeroToArrLength02.fs
@@ -0,0 +1,7 @@
+// #Regression #CodeGen #Optimizations #ControlFlow #NoMono #ReqNOMT 
+//
+// Regression test for FSHARP1.0:4461
+module ZeroToArrLength02
+let f1(arr:int[]) = 
+    for i = 0 to Array.length arr - 1 do 
+        arr.[i] <- i
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ZeroToArrLength02.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ZeroToArrLength02.fs.il.bsl
new file mode 100644
index 00000000000..e8c4e29f45d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ForLoop/RealInternalSignatureOn/ZeroToArrLength02.fs.il.bsl
@@ -0,0 +1,99 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  f1(int32[] arr) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.0
+    IL_0003:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Length<int32>(!!0[])
+    IL_0008:  ldc.i4.1
+    IL_0009:  sub
+    IL_000a:  stloc.0
+    IL_000b:  ldloc.0
+    IL_000c:  ldloc.1
+    IL_000d:  blt.s      IL_0021
+
+    IL_000f:  ldarg.0
+    IL_0010:  ldloc.1
+    IL_0011:  ldloc.1
+    IL_0012:  stelem     [runtime]System.Int32
+    IL_0017:  ldloc.1
+    IL_0018:  ldc.i4.1
+    IL_0019:  add
+    IL_001a:  stloc.1
+    IL_001b:  ldloc.1
+    IL_001c:  ldloc.0
+    IL_001d:  ldc.i4.1
+    IL_001e:  add
+    IL_001f:  bne.un.s   IL_000f
+
+    IL_0021:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GenIter04.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GenIter04_RealInternalSignatureOff.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GenIter04.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GenIter04_RealInternalSignatureOff.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GenIter04.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GenIter04_RealInternalSignatureOff.fs.il.bsl
similarity index 96%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GenIter04.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GenIter04_RealInternalSignatureOff.fs.il.bsl
index 659bb67ed6d..8ff1796aaff 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GenIter04.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GenIter04_RealInternalSignatureOff.fs.il.bsl
@@ -43,8 +43,7 @@
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
-  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
-          get_squaresOfOneToTenD() cil managed
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_squaresOfOneToTenD() cil managed
   {
     
     .maxstack  8
@@ -85,8 +84,8 @@
     IL_0002:  ldc.i4.1
     IL_0003:  ldc.i4.s   10
     IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
-                                                                                                                                                                           int32,
-                                                                                                                                                                           int32)
+                                                                                                                                                                     int32,
+                                                                                                                                                                     int32)
     IL_000a:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
     IL_000f:  stloc.2
     .try
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GenIter04_RealInternalSignatureOn.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GenIter04_RealInternalSignatureOn.fs
new file mode 100644
index 00000000000..446e373977c
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GenIter04_RealInternalSignatureOn.fs
@@ -0,0 +1,4 @@
+// #Regression #NoMono #NoMT #CodeGen #EmittedIL 
+// Regression test for FSHARP1.0:5646
+
+let squaresOfOneToTenD = [ for x in 0 .. 10 -> x * x ]
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GenIter04_RealInternalSignatureOn.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GenIter04_RealInternalSignatureOn.fs.il.bsl
new file mode 100644
index 00000000000..84e9c999f30
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GenIter04_RealInternalSignatureOn.fs.il.bsl
@@ -0,0 +1,158 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> squaresOfOneToTenD@4
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_squaresOfOneToTenD() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::squaresOfOneToTenD@4
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_2,
+             int32 V_3,
+             class [runtime]System.IDisposable V_4)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.0
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.s   10
+    IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                     int32,
+                                                                                                                                                                     int32)
+    IL_000a:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_000f:  stloc.1
+    .try
+    {
+      IL_0010:  br.s       IL_0024
+
+      IL_0012:  ldloc.1
+      IL_0013:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0018:  stloc.3
+      IL_0019:  ldloca.s   V_0
+      IL_001b:  ldloc.3
+      IL_001c:  ldloc.3
+      IL_001d:  mul
+      IL_001e:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Add(!0)
+      IL_0023:  nop
+      IL_0024:  ldloc.1
+      IL_0025:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_002a:  brtrue.s   IL_0012
+
+      IL_002c:  ldnull
+      IL_002d:  stloc.2
+      IL_002e:  leave.s    IL_0045
+
+    }  
+    finally
+    {
+      IL_0030:  ldloc.1
+      IL_0031:  isinst     [runtime]System.IDisposable
+      IL_0036:  stloc.s    V_4
+      IL_0038:  ldloc.s    V_4
+      IL_003a:  brfalse.s  IL_0044
+
+      IL_003c:  ldloc.s    V_4
+      IL_003e:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0043:  endfinally
+      IL_0044:  endfinally
+    }  
+    IL_0045:  ldloc.2
+    IL_0046:  pop
+    IL_0047:  ldloca.s   V_0
+    IL_0049:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Close()
+    IL_004e:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::squaresOfOneToTenD@4
+    IL_0053:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          squaresOfOneToTenD()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_squaresOfOneToTenD()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GeneratedIterators.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GeneratedIterators.fs
index b88d553fe4e..68899c67afe 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GeneratedIterators.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/GeneratedIterators/GeneratedIterators.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open Xunit
 open FSharp.Test
@@ -35,7 +35,15 @@ module GeneratedIterators =
         |> verifyCompilation
 
     // SOURCE=GenIter04.fs   SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd GenIter04.exe"	# GenIter04.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"GenIter04.fs"|])>]
-    let ``GenIter04_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"GenIter04_RealInternalSignatureOff.fs"|])>]
+    let ``GenIter04_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=GenIter04.fs   SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd GenIter04.exe"	# GenIter04.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"GenIter04_RealInternalSignatureOn.fs"|])>]
+    let ``GenIter04_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Inlining.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Inlining.fs
index ea0d10857ff..f716ffdffef 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Inlining.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Inlining.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open Xunit
 open FSharp.Test
@@ -17,9 +17,17 @@ module Inlining =
         |> verifyILBaseline
 
     // SOURCE=Match01.fs SCFLAGS="-a --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Match01.dll"	# Match01.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Match01.fs"|])>]
-    let ``Match01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Match01_RealInternalSignatureOn.fs"|])>]
+    let ``Match01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    // SOURCE=Match01.fs SCFLAGS="-a --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Match01.dll"	# Match01.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Match01_RealInternalSignatureOff.fs"|])>]
+    let ``Match01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     // SOURCE=Match02.fs SCFLAGS="-a --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Match02.dll"	# Match02.fs
@@ -44,7 +52,9 @@ let found = data |> List.contains nan
         |> asExe
         |> compile
         (* This is the essential aspect of the IL we are interested in - doing a direct specialized 'ceq' on primitive values, and not going via a GenericEqualityIntrinsic call*)
-        |> verifyIL ["""
+        |> verifyIL
+#if Release
+            ["""
     .method assembly static bool  contains@1<a>(!!a e,
                                                   class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> xs1) cil managed
       {
@@ -85,4 +95,47 @@ let found = data |> List.contains nan
         IL_0030:  starg.s    e
         IL_0032:  br.s       IL_0000
       }"""]
+#else
+            ["""
+  .method assembly static bool  contains@1<a>(!!a e,
+                                              class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> xs1) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> V_1,
+             float64 V_2)
+    IL_0000:  ldarg.1
+    IL_0001:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::get_TailOrNull()
+    IL_0006:  brfalse.s  IL_000a
+
+    IL_0008:  br.s       IL_000c
+
+    IL_000a:  ldc.i4.0
+    IL_000b:  ret
+
+    IL_000c:  ldarg.1
+    IL_000d:  stloc.0
+    IL_000e:  ldloc.0
+    IL_000f:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::get_TailOrNull()
+    IL_0014:  stloc.1
+    IL_0015:  ldloc.0
+    IL_0016:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::get_HeadOrDefault()
+    IL_001b:  stloc.2
+    IL_001c:  call       float64 [FSharp.Core]Microsoft.FSharp.Core.Operators::get_NaN()
+    IL_0021:  ldloc.2
+    IL_0022:  ceq
+    IL_0024:  brfalse.s  IL_0028
+
+    IL_0026:  ldc.i4.1
+    IL_0027:  ret
+
+    IL_0028:  ldarg.0
+    IL_0029:  ldloc.1
+    IL_002a:  starg.s    xs1
+    IL_002c:  starg.s    e
+    IL_002e:  br.s       IL_0000
+  }"""]
+#endif
 
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOff.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOff.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOff.fs.il.net472.debug.bsl
similarity index 78%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOff.fs.il.net472.debug.bsl
index c0c77ecf960..5e771165fc5 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01.fs.il.net472.debug.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOff.fs.il.net472.debug.bsl
@@ -39,15 +39,15 @@
 
 
 
-.class public abstract auto ansi sealed assembly
+.class public abstract auto ansi sealed Match01
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
   .class abstract auto autochar serializable nested public beforefieldinit Test1
          extends [runtime]System.Object
-         implements class [runtime]System.IEquatable`1<class assembly/Test1>,
+         implements class [runtime]System.IEquatable`1<class Match01/Test1>,
                     [runtime]System.Collections.IStructuralEquatable,
-                    class [runtime]System.IComparable`1<class assembly/Test1>,
+                    class [runtime]System.IComparable`1<class Match01/Test1>,
                     [runtime]System.IComparable,
                     [runtime]System.Collections.IStructuralComparable
   {
@@ -64,7 +64,7 @@
     } 
 
     .class auto ansi serializable nested public beforefieldinit specialname X11
-           extends assembly/Test1
+           extends Match01/Test1
     {
       .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
                                                                                                                             2B 58 31 31 40 44 65 62 75 67 54 79 70 65 50 72   
@@ -75,8 +75,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(int32 item) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
       {
         .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -87,22 +86,21 @@
         .maxstack  8
         IL_0000:  ldarg.0
         IL_0001:  ldc.i4.0
-        IL_0002:  call       instance void assembly/Test1::.ctor(int32)
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
         IL_0007:  ldarg.0
         IL_0008:  ldarg.1
-        IL_0009:  stfld      int32 assembly/Test1/X11::item
+        IL_0009:  stfld      int32 Match01/Test1/X11::item
         IL_000e:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      int32 assembly/Test1/X11::item
+        IL_0001:  ldfld      int32 Match01/Test1/X11::item
         IL_0006:  ret
       } 
 
@@ -113,12 +111,12 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X11::get_Item()
+        .get instance int32 Match01/Test1/X11::get_Item()
       } 
     } 
 
     .class auto ansi serializable nested public beforefieldinit specialname X12
-           extends assembly/Test1
+           extends Match01/Test1
     {
       .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
                                                                                                                             2B 58 31 32 40 44 65 62 75 67 54 79 70 65 50 72   
@@ -129,8 +127,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(int32 item) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
       {
         .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -141,22 +138,21 @@
         .maxstack  8
         IL_0000:  ldarg.0
         IL_0001:  ldc.i4.1
-        IL_0002:  call       instance void assembly/Test1::.ctor(int32)
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
         IL_0007:  ldarg.0
         IL_0008:  ldarg.1
-        IL_0009:  stfld      int32 assembly/Test1/X12::item
+        IL_0009:  stfld      int32 Match01/Test1/X12::item
         IL_000e:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      int32 assembly/Test1/X12::item
+        IL_0001:  ldfld      int32 Match01/Test1/X12::item
         IL_0006:  ret
       } 
 
@@ -167,12 +163,12 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 01 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X12::get_Item()
+        .get instance int32 Match01/Test1/X12::get_Item()
       } 
     } 
 
     .class auto ansi serializable nested public beforefieldinit specialname X13
-           extends assembly/Test1
+           extends Match01/Test1
     {
       .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
                                                                                                                             2B 58 31 33 40 44 65 62 75 67 54 79 70 65 50 72   
@@ -183,8 +179,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(int32 item) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
       {
         .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -195,22 +190,21 @@
         .maxstack  8
         IL_0000:  ldarg.0
         IL_0001:  ldc.i4.2
-        IL_0002:  call       instance void assembly/Test1::.ctor(int32)
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
         IL_0007:  ldarg.0
         IL_0008:  ldarg.1
-        IL_0009:  stfld      int32 assembly/Test1/X13::item
+        IL_0009:  stfld      int32 Match01/Test1/X13::item
         IL_000e:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      int32 assembly/Test1/X13::item
+        IL_0001:  ldfld      int32 Match01/Test1/X13::item
         IL_0006:  ret
       } 
 
@@ -221,12 +215,12 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 02 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X13::get_Item()
+        .get instance int32 Match01/Test1/X13::get_Item()
       } 
     } 
 
     .class auto ansi serializable nested public beforefieldinit specialname X14
-           extends assembly/Test1
+           extends Match01/Test1
     {
       .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
                                                                                                                             2B 58 31 34 40 44 65 62 75 67 54 79 70 65 50 72   
@@ -237,8 +231,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(int32 item) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
       {
         .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -249,22 +242,21 @@
         .maxstack  8
         IL_0000:  ldarg.0
         IL_0001:  ldc.i4.3
-        IL_0002:  call       instance void assembly/Test1::.ctor(int32)
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
         IL_0007:  ldarg.0
         IL_0008:  ldarg.1
-        IL_0009:  stfld      int32 assembly/Test1/X14::item
+        IL_0009:  stfld      int32 Match01/Test1/X14::item
         IL_000e:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      int32 assembly/Test1/X14::item
+        IL_0001:  ldfld      int32 Match01/Test1/X14::item
         IL_0006:  ret
       } 
 
@@ -275,19 +267,18 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 03 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X14::get_Item()
+        .get instance int32 Match01/Test1/X14::get_Item()
       } 
     } 
 
     .class auto ansi nested assembly beforefieldinit specialname X11@DebugTypeProxy
            extends [runtime]System.Object
     {
-      .field assembly class assembly/Test1/X11 _obj
+      .field assembly class Match01/Test1/X11 _obj
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method public specialname rtspecialname 
-              instance void  .ctor(class assembly/Test1/X11 obj) cil managed
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X11 obj) cil managed
       {
         .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -300,20 +291,19 @@
         IL_0001:  call       instance void [runtime]System.Object::.ctor()
         IL_0006:  ldarg.0
         IL_0007:  ldarg.1
-        IL_0008:  stfld      class assembly/Test1/X11 assembly/Test1/X11@DebugTypeProxy::_obj
+        IL_0008:  stfld      class Match01/Test1/X11 Match01/Test1/X11@DebugTypeProxy::_obj
         IL_000d:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      class assembly/Test1/X11 assembly/Test1/X11@DebugTypeProxy::_obj
-        IL_0006:  ldfld      int32 assembly/Test1/X11::item
+        IL_0001:  ldfld      class Match01/Test1/X11 Match01/Test1/X11@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X11::item
         IL_000b:  ret
       } 
 
@@ -324,19 +314,18 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X11@DebugTypeProxy::get_Item()
+        .get instance int32 Match01/Test1/X11@DebugTypeProxy::get_Item()
       } 
     } 
 
     .class auto ansi nested assembly beforefieldinit specialname X12@DebugTypeProxy
            extends [runtime]System.Object
     {
-      .field assembly class assembly/Test1/X12 _obj
+      .field assembly class Match01/Test1/X12 _obj
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method public specialname rtspecialname 
-              instance void  .ctor(class assembly/Test1/X12 obj) cil managed
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X12 obj) cil managed
       {
         .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -349,20 +338,19 @@
         IL_0001:  call       instance void [runtime]System.Object::.ctor()
         IL_0006:  ldarg.0
         IL_0007:  ldarg.1
-        IL_0008:  stfld      class assembly/Test1/X12 assembly/Test1/X12@DebugTypeProxy::_obj
+        IL_0008:  stfld      class Match01/Test1/X12 Match01/Test1/X12@DebugTypeProxy::_obj
         IL_000d:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      class assembly/Test1/X12 assembly/Test1/X12@DebugTypeProxy::_obj
-        IL_0006:  ldfld      int32 assembly/Test1/X12::item
+        IL_0001:  ldfld      class Match01/Test1/X12 Match01/Test1/X12@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X12::item
         IL_000b:  ret
       } 
 
@@ -373,19 +361,18 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 01 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X12@DebugTypeProxy::get_Item()
+        .get instance int32 Match01/Test1/X12@DebugTypeProxy::get_Item()
       } 
     } 
 
     .class auto ansi nested assembly beforefieldinit specialname X13@DebugTypeProxy
            extends [runtime]System.Object
     {
-      .field assembly class assembly/Test1/X13 _obj
+      .field assembly class Match01/Test1/X13 _obj
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method public specialname rtspecialname 
-              instance void  .ctor(class assembly/Test1/X13 obj) cil managed
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X13 obj) cil managed
       {
         .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -398,20 +385,19 @@
         IL_0001:  call       instance void [runtime]System.Object::.ctor()
         IL_0006:  ldarg.0
         IL_0007:  ldarg.1
-        IL_0008:  stfld      class assembly/Test1/X13 assembly/Test1/X13@DebugTypeProxy::_obj
+        IL_0008:  stfld      class Match01/Test1/X13 Match01/Test1/X13@DebugTypeProxy::_obj
         IL_000d:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      class assembly/Test1/X13 assembly/Test1/X13@DebugTypeProxy::_obj
-        IL_0006:  ldfld      int32 assembly/Test1/X13::item
+        IL_0001:  ldfld      class Match01/Test1/X13 Match01/Test1/X13@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X13::item
         IL_000b:  ret
       } 
 
@@ -422,19 +408,18 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 02 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X13@DebugTypeProxy::get_Item()
+        .get instance int32 Match01/Test1/X13@DebugTypeProxy::get_Item()
       } 
     } 
 
     .class auto ansi nested assembly beforefieldinit specialname X14@DebugTypeProxy
            extends [runtime]System.Object
     {
-      .field assembly class assembly/Test1/X14 _obj
+      .field assembly class Match01/Test1/X14 _obj
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method public specialname rtspecialname 
-              instance void  .ctor(class assembly/Test1/X14 obj) cil managed
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X14 obj) cil managed
       {
         .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -447,20 +432,19 @@
         IL_0001:  call       instance void [runtime]System.Object::.ctor()
         IL_0006:  ldarg.0
         IL_0007:  ldarg.1
-        IL_0008:  stfld      class assembly/Test1/X14 assembly/Test1/X14@DebugTypeProxy::_obj
+        IL_0008:  stfld      class Match01/Test1/X14 Match01/Test1/X14@DebugTypeProxy::_obj
         IL_000d:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      class assembly/Test1/X14 assembly/Test1/X14@DebugTypeProxy::_obj
-        IL_0006:  ldfld      int32 assembly/Test1/X14::item
+        IL_0001:  ldfld      class Match01/Test1/X14 Match01/Test1/X14@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X14::item
         IL_000b:  ret
       } 
 
@@ -471,7 +455,7 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 03 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X14@DebugTypeProxy::get_Item()
+        .get instance int32 Match01/Test1/X14@DebugTypeProxy::get_Item()
       } 
     } 
 
@@ -479,8 +463,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(int32 _tag) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(int32 _tag) cil managed
     {
       .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                               class [runtime]System.Type) = ( 01 00 E0 07 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -493,157 +476,145 @@
       IL_0001:  call       instance void [runtime]System.Object::.ctor()
       IL_0006:  ldarg.0
       IL_0007:  ldarg.1
-      IL_0008:  stfld      int32 assembly/Test1::_tag
+      IL_0008:  stfld      int32 Match01/Test1::_tag
       IL_000d:  ret
     } 
 
-    .method public static class assembly/Test1 
-            NewX11(int32 item) cil managed
+    .method public static class Match01/Test1 NewX11(int32 item) cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  newobj     instance void assembly/Test1/X11::.ctor(int32)
+      IL_0001:  newobj     instance void Match01/Test1/X11::.ctor(int32)
       IL_0006:  ret
     } 
 
-    .method public hidebysig instance bool 
-            get_IsX11() cil managed
+    .method public hidebysig instance bool get_IsX11() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
       IL_0006:  ldc.i4.0
       IL_0007:  ceq
       IL_0009:  ret
     } 
 
-    .method public static class assembly/Test1 
-            NewX12(int32 item) cil managed
+    .method public static class Match01/Test1 NewX12(int32 item) cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 01 00 00 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  newobj     instance void assembly/Test1/X12::.ctor(int32)
+      IL_0001:  newobj     instance void Match01/Test1/X12::.ctor(int32)
       IL_0006:  ret
     } 
 
-    .method public hidebysig instance bool 
-            get_IsX12() cil managed
+    .method public hidebysig instance bool get_IsX12() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
       IL_0006:  ldc.i4.1
       IL_0007:  ceq
       IL_0009:  ret
     } 
 
-    .method public static class assembly/Test1 
-            NewX13(int32 item) cil managed
+    .method public static class Match01/Test1 NewX13(int32 item) cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 02 00 00 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  newobj     instance void assembly/Test1/X13::.ctor(int32)
+      IL_0001:  newobj     instance void Match01/Test1/X13::.ctor(int32)
       IL_0006:  ret
     } 
 
-    .method public hidebysig instance bool 
-            get_IsX13() cil managed
+    .method public hidebysig instance bool get_IsX13() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
       IL_0006:  ldc.i4.2
       IL_0007:  ceq
       IL_0009:  ret
     } 
 
-    .method public static class assembly/Test1 
-            NewX14(int32 item) cil managed
+    .method public static class Match01/Test1 NewX14(int32 item) cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 03 00 00 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  newobj     instance void assembly/Test1/X14::.ctor(int32)
+      IL_0001:  newobj     instance void Match01/Test1/X14::.ctor(int32)
       IL_0006:  ret
     } 
 
-    .method public hidebysig instance bool 
-            get_IsX14() cil managed
+    .method public hidebysig instance bool get_IsX14() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
       IL_0006:  ldc.i4.3
       IL_0007:  ceq
       IL_0009:  ret
     } 
 
-    .method public hidebysig instance int32 
-            get_Tag() cil managed
+    .method public hidebysig instance int32 get_Tag() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  ldfld      int32 assembly/Test1::_tag
+      IL_0001:  ldfld      int32 Match01/Test1::_tag
       IL_0006:  ret
     } 
 
-    .method assembly hidebysig specialname 
-            instance object  __DebugDisplay() cil managed
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldstr      "%+0.8A"
-      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
-      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
       IL_000f:  ldarg.0
-      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>::Invoke(!0)
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>::Invoke(!0)
       IL_0015:  ret
     } 
 
-    .method public strict virtual instance string 
-            ToString() cil managed
+    .method public strict virtual instance string ToString() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldstr      "%+A"
-      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class assembly/Test1>::.ctor(string)
-      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class Match01/Test1>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
       IL_000f:  ldarg.0
-      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>::Invoke(!0)
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>::Invoke(!0)
       IL_0015:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(class assembly/Test1 obj) cil managed
+    .method public hidebysig virtual final instance int32  CompareTo(class Match01/Test1 obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -657,8 +628,8 @@
       IL_0006:  ldarg.0
       IL_0007:  ldarg.1
       IL_0008:  ldnull
-      IL_0009:  call       int32 assembly::CompareTo$cont@4(class assembly/Test1,
-                                                           class assembly/Test1,
+      IL_0009:  call       int32 Match01::CompareTo$cont@4(class Match01/Test1,
+                                                           class Match01/Test1,
                                                            class [FSharp.Core]Microsoft.FSharp.Core.Unit)
       IL_000e:  ret
 
@@ -675,16 +646,15 @@
       IL_0017:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(object obj) cil managed
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
       IL_0001:  ldarg.1
-      IL_0002:  unbox.any  assembly/Test1
-      IL_0007:  callvirt   instance int32 assembly/Test1::CompareTo(class assembly/Test1)
+      IL_0002:  unbox.any  Match01/Test1
+      IL_0007:  callvirt   instance int32 Match01/Test1::CompareTo(class Match01/Test1)
       IL_000c:  ret
     } 
 
@@ -695,22 +665,22 @@
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  5
-      .locals init (class assembly/Test1 V_0)
+      .locals init (class Match01/Test1 V_0)
       IL_0000:  ldarg.1
-      IL_0001:  unbox.any  assembly/Test1
+      IL_0001:  unbox.any  Match01/Test1
       IL_0006:  stloc.0
       IL_0007:  ldarg.0
       IL_0008:  brfalse.s  IL_001d
 
       IL_000a:  ldarg.1
-      IL_000b:  unbox.any  assembly/Test1
+      IL_000b:  unbox.any  Match01/Test1
       IL_0010:  brfalse.s  IL_001b
 
       IL_0012:  ldarg.0
       IL_0013:  ldloc.0
       IL_0014:  ldnull
-      IL_0015:  call       int32 assembly::'CompareTo$cont@4-1'(class assembly/Test1,
-                                                               class assembly/Test1,
+      IL_0015:  call       int32 Match01::'CompareTo$cont@4-1'(class Match01/Test1,
+                                                               class Match01/Test1,
                                                                class [FSharp.Core]Microsoft.FSharp.Core.Unit)
       IL_001a:  ret
 
@@ -718,7 +688,7 @@
       IL_001c:  ret
 
       IL_001d:  ldarg.1
-      IL_001e:  unbox.any  assembly/Test1
+      IL_001e:  unbox.any  Match01/Test1
       IL_0023:  brfalse.s  IL_0027
 
       IL_0025:  ldc.i4.m1
@@ -728,37 +698,36 @@
       IL_0028:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  7
       .locals init (int32 V_0,
-               class assembly/Test1/X11 V_1,
-               class assembly/Test1/X12 V_2,
-               class assembly/Test1/X13 V_3,
-               class assembly/Test1/X14 V_4)
+               class Match01/Test1/X11 V_1,
+               class Match01/Test1/X12 V_2,
+               class Match01/Test1/X13 V_3,
+               class Match01/Test1/X14 V_4)
       IL_0000:  ldarg.0
       IL_0001:  brfalse    IL_00a5
 
       IL_0006:  ldc.i4.0
       IL_0007:  stloc.0
       IL_0008:  ldarg.0
-      IL_0009:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0009:  call       instance int32 Match01/Test1::get_Tag()
       IL_000e:  switch     ( 
                             IL_0023,
                             IL_0043,
                             IL_0063,
                             IL_0083)
       IL_0023:  ldarg.0
-      IL_0024:  castclass  assembly/Test1/X11
+      IL_0024:  castclass  Match01/Test1/X11
       IL_0029:  stloc.1
       IL_002a:  ldc.i4.0
       IL_002b:  stloc.0
       IL_002c:  ldc.i4     0x9e3779b9
       IL_0031:  ldloc.1
-      IL_0032:  ldfld      int32 assembly/Test1/X11::item
+      IL_0032:  ldfld      int32 Match01/Test1/X11::item
       IL_0037:  ldloc.0
       IL_0038:  ldc.i4.6
       IL_0039:  shl
@@ -773,13 +742,13 @@
       IL_0042:  ret
 
       IL_0043:  ldarg.0
-      IL_0044:  castclass  assembly/Test1/X12
+      IL_0044:  castclass  Match01/Test1/X12
       IL_0049:  stloc.2
       IL_004a:  ldc.i4.1
       IL_004b:  stloc.0
       IL_004c:  ldc.i4     0x9e3779b9
       IL_0051:  ldloc.2
-      IL_0052:  ldfld      int32 assembly/Test1/X12::item
+      IL_0052:  ldfld      int32 Match01/Test1/X12::item
       IL_0057:  ldloc.0
       IL_0058:  ldc.i4.6
       IL_0059:  shl
@@ -794,13 +763,13 @@
       IL_0062:  ret
 
       IL_0063:  ldarg.0
-      IL_0064:  castclass  assembly/Test1/X13
+      IL_0064:  castclass  Match01/Test1/X13
       IL_0069:  stloc.3
       IL_006a:  ldc.i4.2
       IL_006b:  stloc.0
       IL_006c:  ldc.i4     0x9e3779b9
       IL_0071:  ldloc.3
-      IL_0072:  ldfld      int32 assembly/Test1/X13::item
+      IL_0072:  ldfld      int32 Match01/Test1/X13::item
       IL_0077:  ldloc.0
       IL_0078:  ldc.i4.6
       IL_0079:  shl
@@ -815,13 +784,13 @@
       IL_0082:  ret
 
       IL_0083:  ldarg.0
-      IL_0084:  castclass  assembly/Test1/X14
+      IL_0084:  castclass  Match01/Test1/X14
       IL_0089:  stloc.s    V_4
       IL_008b:  ldc.i4.3
       IL_008c:  stloc.0
       IL_008d:  ldc.i4     0x9e3779b9
       IL_0092:  ldloc.s    V_4
-      IL_0094:  ldfld      int32 assembly/Test1/X14::item
+      IL_0094:  ldfld      int32 Match01/Test1/X14::item
       IL_0099:  ldloc.0
       IL_009a:  ldc.i4.6
       IL_009b:  shl
@@ -839,15 +808,14 @@
       IL_00a6:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode() cil managed
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
       IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
-      IL_0006:  callvirt   instance int32 assembly/Test1::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_0006:  callvirt   instance int32 Match01/Test1::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
       IL_000b:  ret
     } 
 
@@ -858,92 +826,92 @@
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  4
-      .locals init (class assembly/Test1 V_0,
+      .locals init (class Match01/Test1 V_0,
                int32 V_1,
                int32 V_2,
-               class assembly/Test1/X11 V_3,
-               class assembly/Test1/X11 V_4,
-               class assembly/Test1/X12 V_5,
-               class assembly/Test1/X12 V_6,
-               class assembly/Test1/X13 V_7,
-               class assembly/Test1/X13 V_8,
-               class assembly/Test1/X14 V_9,
-               class assembly/Test1/X14 V_10)
+               class Match01/Test1/X11 V_3,
+               class Match01/Test1/X11 V_4,
+               class Match01/Test1/X12 V_5,
+               class Match01/Test1/X12 V_6,
+               class Match01/Test1/X13 V_7,
+               class Match01/Test1/X13 V_8,
+               class Match01/Test1/X14 V_9,
+               class Match01/Test1/X14 V_10)
       IL_0000:  ldarg.0
       IL_0001:  brfalse    IL_00c9
 
       IL_0006:  ldarg.1
-      IL_0007:  isinst     assembly/Test1
+      IL_0007:  isinst     Match01/Test1
       IL_000c:  stloc.0
       IL_000d:  ldloc.0
       IL_000e:  brfalse    IL_00c7
 
       IL_0013:  ldarg.0
-      IL_0014:  ldfld      int32 assembly/Test1::_tag
+      IL_0014:  ldfld      int32 Match01/Test1::_tag
       IL_0019:  stloc.1
       IL_001a:  ldloc.0
-      IL_001b:  ldfld      int32 assembly/Test1::_tag
+      IL_001b:  ldfld      int32 Match01/Test1::_tag
       IL_0020:  stloc.2
       IL_0021:  ldloc.1
       IL_0022:  ldloc.2
       IL_0023:  bne.un     IL_00c5
 
       IL_0028:  ldarg.0
-      IL_0029:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0029:  call       instance int32 Match01/Test1::get_Tag()
       IL_002e:  switch     ( 
                             IL_0043,
                             IL_0062,
                             IL_0083,
                             IL_00a4)
       IL_0043:  ldarg.0
-      IL_0044:  castclass  assembly/Test1/X11
+      IL_0044:  castclass  Match01/Test1/X11
       IL_0049:  stloc.3
       IL_004a:  ldloc.0
-      IL_004b:  castclass  assembly/Test1/X11
+      IL_004b:  castclass  Match01/Test1/X11
       IL_0050:  stloc.s    V_4
       IL_0052:  ldloc.3
-      IL_0053:  ldfld      int32 assembly/Test1/X11::item
+      IL_0053:  ldfld      int32 Match01/Test1/X11::item
       IL_0058:  ldloc.s    V_4
-      IL_005a:  ldfld      int32 assembly/Test1/X11::item
+      IL_005a:  ldfld      int32 Match01/Test1/X11::item
       IL_005f:  ceq
       IL_0061:  ret
 
       IL_0062:  ldarg.0
-      IL_0063:  castclass  assembly/Test1/X12
+      IL_0063:  castclass  Match01/Test1/X12
       IL_0068:  stloc.s    V_5
       IL_006a:  ldloc.0
-      IL_006b:  castclass  assembly/Test1/X12
+      IL_006b:  castclass  Match01/Test1/X12
       IL_0070:  stloc.s    V_6
       IL_0072:  ldloc.s    V_5
-      IL_0074:  ldfld      int32 assembly/Test1/X12::item
+      IL_0074:  ldfld      int32 Match01/Test1/X12::item
       IL_0079:  ldloc.s    V_6
-      IL_007b:  ldfld      int32 assembly/Test1/X12::item
+      IL_007b:  ldfld      int32 Match01/Test1/X12::item
       IL_0080:  ceq
       IL_0082:  ret
 
       IL_0083:  ldarg.0
-      IL_0084:  castclass  assembly/Test1/X13
+      IL_0084:  castclass  Match01/Test1/X13
       IL_0089:  stloc.s    V_7
       IL_008b:  ldloc.0
-      IL_008c:  castclass  assembly/Test1/X13
+      IL_008c:  castclass  Match01/Test1/X13
       IL_0091:  stloc.s    V_8
       IL_0093:  ldloc.s    V_7
-      IL_0095:  ldfld      int32 assembly/Test1/X13::item
+      IL_0095:  ldfld      int32 Match01/Test1/X13::item
       IL_009a:  ldloc.s    V_8
-      IL_009c:  ldfld      int32 assembly/Test1/X13::item
+      IL_009c:  ldfld      int32 Match01/Test1/X13::item
       IL_00a1:  ceq
       IL_00a3:  ret
 
       IL_00a4:  ldarg.0
-      IL_00a5:  castclass  assembly/Test1/X14
+      IL_00a5:  castclass  Match01/Test1/X14
       IL_00aa:  stloc.s    V_9
       IL_00ac:  ldloc.0
-      IL_00ad:  castclass  assembly/Test1/X14
+      IL_00ad:  castclass  Match01/Test1/X14
       IL_00b2:  stloc.s    V_10
       IL_00b4:  ldloc.s    V_9
-      IL_00b6:  ldfld      int32 assembly/Test1/X14::item
+      IL_00b6:  ldfld      int32 Match01/Test1/X14::item
       IL_00bb:  ldloc.s    V_10
-      IL_00bd:  ldfld      int32 assembly/Test1/X14::item
+      IL_00bd:  ldfld      int32 Match01/Test1/X14::item
       IL_00c2:  ceq
       IL_00c4:  ret
 
@@ -961,22 +929,21 @@
       IL_00d0:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance bool  Equals(class assembly/Test1 obj) cil managed
+    .method public hidebysig virtual final instance bool  Equals(class Match01/Test1 obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  4
       .locals init (int32 V_0,
                int32 V_1,
-               class assembly/Test1/X11 V_2,
-               class assembly/Test1/X11 V_3,
-               class assembly/Test1/X12 V_4,
-               class assembly/Test1/X12 V_5,
-               class assembly/Test1/X13 V_6,
-               class assembly/Test1/X13 V_7,
-               class assembly/Test1/X14 V_8,
-               class assembly/Test1/X14 V_9)
+               class Match01/Test1/X11 V_2,
+               class Match01/Test1/X11 V_3,
+               class Match01/Test1/X12 V_4,
+               class Match01/Test1/X12 V_5,
+               class Match01/Test1/X13 V_6,
+               class Match01/Test1/X13 V_7,
+               class Match01/Test1/X14 V_8,
+               class Match01/Test1/X14 V_9)
       IL_0000:  ldarg.0
       IL_0001:  brfalse    IL_00c0
 
@@ -984,71 +951,71 @@
       IL_0007:  brfalse    IL_00be
 
       IL_000c:  ldarg.0
-      IL_000d:  ldfld      int32 assembly/Test1::_tag
+      IL_000d:  ldfld      int32 Match01/Test1::_tag
       IL_0012:  stloc.0
       IL_0013:  ldarg.1
-      IL_0014:  ldfld      int32 assembly/Test1::_tag
+      IL_0014:  ldfld      int32 Match01/Test1::_tag
       IL_0019:  stloc.1
       IL_001a:  ldloc.0
       IL_001b:  ldloc.1
       IL_001c:  bne.un     IL_00bc
 
       IL_0021:  ldarg.0
-      IL_0022:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0022:  call       instance int32 Match01/Test1::get_Tag()
       IL_0027:  switch     ( 
                             IL_003c,
                             IL_0059,
                             IL_007a,
                             IL_009b)
       IL_003c:  ldarg.0
-      IL_003d:  castclass  assembly/Test1/X11
+      IL_003d:  castclass  Match01/Test1/X11
       IL_0042:  stloc.2
       IL_0043:  ldarg.1
-      IL_0044:  castclass  assembly/Test1/X11
+      IL_0044:  castclass  Match01/Test1/X11
       IL_0049:  stloc.3
       IL_004a:  ldloc.2
-      IL_004b:  ldfld      int32 assembly/Test1/X11::item
+      IL_004b:  ldfld      int32 Match01/Test1/X11::item
       IL_0050:  ldloc.3
-      IL_0051:  ldfld      int32 assembly/Test1/X11::item
+      IL_0051:  ldfld      int32 Match01/Test1/X11::item
       IL_0056:  ceq
       IL_0058:  ret
 
       IL_0059:  ldarg.0
-      IL_005a:  castclass  assembly/Test1/X12
+      IL_005a:  castclass  Match01/Test1/X12
       IL_005f:  stloc.s    V_4
       IL_0061:  ldarg.1
-      IL_0062:  castclass  assembly/Test1/X12
+      IL_0062:  castclass  Match01/Test1/X12
       IL_0067:  stloc.s    V_5
       IL_0069:  ldloc.s    V_4
-      IL_006b:  ldfld      int32 assembly/Test1/X12::item
+      IL_006b:  ldfld      int32 Match01/Test1/X12::item
       IL_0070:  ldloc.s    V_5
-      IL_0072:  ldfld      int32 assembly/Test1/X12::item
+      IL_0072:  ldfld      int32 Match01/Test1/X12::item
       IL_0077:  ceq
       IL_0079:  ret
 
       IL_007a:  ldarg.0
-      IL_007b:  castclass  assembly/Test1/X13
+      IL_007b:  castclass  Match01/Test1/X13
       IL_0080:  stloc.s    V_6
       IL_0082:  ldarg.1
-      IL_0083:  castclass  assembly/Test1/X13
+      IL_0083:  castclass  Match01/Test1/X13
       IL_0088:  stloc.s    V_7
       IL_008a:  ldloc.s    V_6
-      IL_008c:  ldfld      int32 assembly/Test1/X13::item
+      IL_008c:  ldfld      int32 Match01/Test1/X13::item
       IL_0091:  ldloc.s    V_7
-      IL_0093:  ldfld      int32 assembly/Test1/X13::item
+      IL_0093:  ldfld      int32 Match01/Test1/X13::item
       IL_0098:  ceq
       IL_009a:  ret
 
       IL_009b:  ldarg.0
-      IL_009c:  castclass  assembly/Test1/X14
+      IL_009c:  castclass  Match01/Test1/X14
       IL_00a1:  stloc.s    V_8
       IL_00a3:  ldarg.1
-      IL_00a4:  castclass  assembly/Test1/X14
+      IL_00a4:  castclass  Match01/Test1/X14
       IL_00a9:  stloc.s    V_9
       IL_00ab:  ldloc.s    V_8
-      IL_00ad:  ldfld      int32 assembly/Test1/X14::item
+      IL_00ad:  ldfld      int32 Match01/Test1/X14::item
       IL_00b2:  ldloc.s    V_9
-      IL_00b4:  ldfld      int32 assembly/Test1/X14::item
+      IL_00b4:  ldfld      int32 Match01/Test1/X14::item
       IL_00b9:  ceq
       IL_00bb:  ret
 
@@ -1066,22 +1033,21 @@
       IL_00c7:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance bool  Equals(object obj) cil managed
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  4
-      .locals init (class assembly/Test1 V_0)
+      .locals init (class Match01/Test1 V_0)
       IL_0000:  ldarg.1
-      IL_0001:  isinst     assembly/Test1
+      IL_0001:  isinst     Match01/Test1
       IL_0006:  stloc.0
       IL_0007:  ldloc.0
       IL_0008:  brfalse.s  IL_0012
 
       IL_000a:  ldarg.0
       IL_000b:  ldloc.0
-      IL_000c:  callvirt   instance bool assembly/Test1::Equals(class assembly/Test1)
+      IL_000c:  callvirt   instance bool Match01/Test1::Equals(class Match01/Test1)
       IL_0011:  ret
 
       IL_0012:  ldc.i4.0
@@ -1093,40 +1059,40 @@
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance int32 assembly/Test1::get_Tag()
+      .get instance int32 Match01/Test1::get_Tag()
     } 
     .property instance bool IsX11()
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance bool assembly/Test1::get_IsX11()
+      .get instance bool Match01/Test1::get_IsX11()
     } 
     .property instance bool IsX12()
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance bool assembly/Test1::get_IsX12()
+      .get instance bool Match01/Test1::get_IsX12()
     } 
     .property instance bool IsX13()
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance bool assembly/Test1::get_IsX13()
+      .get instance bool Match01/Test1::get_IsX13()
     } 
     .property instance bool IsX14()
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance bool assembly/Test1::get_IsX14()
+      .get instance bool Match01/Test1::get_IsX14()
     } 
   } 
 
-  .method assembly static int32  CompareTo$cont@4(class assembly/Test1 this,
-                                                  class assembly/Test1 obj,
+  .method assembly static int32  CompareTo$cont@4(class Match01/Test1 this,
+                                                  class Match01/Test1 obj,
                                                   class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
   {
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -1134,47 +1100,47 @@
     .maxstack  5
     .locals init (int32 V_0,
              int32 V_1,
-             class assembly/Test1/X11 V_2,
-             class assembly/Test1/X11 V_3,
+             class Match01/Test1/X11 V_2,
+             class Match01/Test1/X11 V_3,
              class [runtime]System.Collections.IComparer V_4,
              int32 V_5,
              int32 V_6,
-             class assembly/Test1/X12 V_7,
-             class assembly/Test1/X12 V_8,
-             class assembly/Test1/X13 V_9,
-             class assembly/Test1/X13 V_10,
-             class assembly/Test1/X14 V_11,
-             class assembly/Test1/X14 V_12)
+             class Match01/Test1/X12 V_7,
+             class Match01/Test1/X12 V_8,
+             class Match01/Test1/X13 V_9,
+             class Match01/Test1/X13 V_10,
+             class Match01/Test1/X14 V_11,
+             class Match01/Test1/X14 V_12)
     IL_0000:  ldarg.0
-    IL_0001:  ldfld      int32 assembly/Test1::_tag
+    IL_0001:  ldfld      int32 Match01/Test1::_tag
     IL_0006:  stloc.0
     IL_0007:  ldarg.1
-    IL_0008:  ldfld      int32 assembly/Test1::_tag
+    IL_0008:  ldfld      int32 Match01/Test1::_tag
     IL_000d:  stloc.1
     IL_000e:  ldloc.0
     IL_000f:  ldloc.1
     IL_0010:  bne.un     IL_0108
 
     IL_0015:  ldarg.0
-    IL_0016:  call       instance int32 assembly/Test1::get_Tag()
+    IL_0016:  call       instance int32 Match01/Test1::get_Tag()
     IL_001b:  switch     ( 
                           IL_0030,
                           IL_0063,
                           IL_009a,
                           IL_00d1)
     IL_0030:  ldarg.0
-    IL_0031:  castclass  assembly/Test1/X11
+    IL_0031:  castclass  Match01/Test1/X11
     IL_0036:  stloc.2
     IL_0037:  ldarg.1
-    IL_0038:  castclass  assembly/Test1/X11
+    IL_0038:  castclass  Match01/Test1/X11
     IL_003d:  stloc.3
     IL_003e:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
     IL_0043:  stloc.s    V_4
     IL_0045:  ldloc.2
-    IL_0046:  ldfld      int32 assembly/Test1/X11::item
+    IL_0046:  ldfld      int32 Match01/Test1/X11::item
     IL_004b:  stloc.s    V_5
     IL_004d:  ldloc.3
-    IL_004e:  ldfld      int32 assembly/Test1/X11::item
+    IL_004e:  ldfld      int32 Match01/Test1/X11::item
     IL_0053:  stloc.s    V_6
     IL_0055:  ldloc.s    V_5
     IL_0057:  ldloc.s    V_6
@@ -1186,18 +1152,18 @@
     IL_0062:  ret
 
     IL_0063:  ldarg.0
-    IL_0064:  castclass  assembly/Test1/X12
+    IL_0064:  castclass  Match01/Test1/X12
     IL_0069:  stloc.s    V_7
     IL_006b:  ldarg.1
-    IL_006c:  castclass  assembly/Test1/X12
+    IL_006c:  castclass  Match01/Test1/X12
     IL_0071:  stloc.s    V_8
     IL_0073:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
     IL_0078:  stloc.s    V_4
     IL_007a:  ldloc.s    V_7
-    IL_007c:  ldfld      int32 assembly/Test1/X12::item
+    IL_007c:  ldfld      int32 Match01/Test1/X12::item
     IL_0081:  stloc.s    V_5
     IL_0083:  ldloc.s    V_8
-    IL_0085:  ldfld      int32 assembly/Test1/X12::item
+    IL_0085:  ldfld      int32 Match01/Test1/X12::item
     IL_008a:  stloc.s    V_6
     IL_008c:  ldloc.s    V_5
     IL_008e:  ldloc.s    V_6
@@ -1209,18 +1175,18 @@
     IL_0099:  ret
 
     IL_009a:  ldarg.0
-    IL_009b:  castclass  assembly/Test1/X13
+    IL_009b:  castclass  Match01/Test1/X13
     IL_00a0:  stloc.s    V_9
     IL_00a2:  ldarg.1
-    IL_00a3:  castclass  assembly/Test1/X13
+    IL_00a3:  castclass  Match01/Test1/X13
     IL_00a8:  stloc.s    V_10
     IL_00aa:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
     IL_00af:  stloc.s    V_4
     IL_00b1:  ldloc.s    V_9
-    IL_00b3:  ldfld      int32 assembly/Test1/X13::item
+    IL_00b3:  ldfld      int32 Match01/Test1/X13::item
     IL_00b8:  stloc.s    V_5
     IL_00ba:  ldloc.s    V_10
-    IL_00bc:  ldfld      int32 assembly/Test1/X13::item
+    IL_00bc:  ldfld      int32 Match01/Test1/X13::item
     IL_00c1:  stloc.s    V_6
     IL_00c3:  ldloc.s    V_5
     IL_00c5:  ldloc.s    V_6
@@ -1232,18 +1198,18 @@
     IL_00d0:  ret
 
     IL_00d1:  ldarg.0
-    IL_00d2:  castclass  assembly/Test1/X14
+    IL_00d2:  castclass  Match01/Test1/X14
     IL_00d7:  stloc.s    V_11
     IL_00d9:  ldarg.1
-    IL_00da:  castclass  assembly/Test1/X14
+    IL_00da:  castclass  Match01/Test1/X14
     IL_00df:  stloc.s    V_12
     IL_00e1:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
     IL_00e6:  stloc.s    V_4
     IL_00e8:  ldloc.s    V_11
-    IL_00ea:  ldfld      int32 assembly/Test1/X14::item
+    IL_00ea:  ldfld      int32 Match01/Test1/X14::item
     IL_00ef:  stloc.s    V_5
     IL_00f1:  ldloc.s    V_12
-    IL_00f3:  ldfld      int32 assembly/Test1/X14::item
+    IL_00f3:  ldfld      int32 Match01/Test1/X14::item
     IL_00f8:  stloc.s    V_6
     IL_00fa:  ldloc.s    V_5
     IL_00fc:  ldloc.s    V_6
@@ -1260,8 +1226,8 @@
     IL_010b:  ret
   } 
 
-  .method assembly static int32  'CompareTo$cont@4-1'(class assembly/Test1 this,
-                                                      class assembly/Test1 objTemp,
+  .method assembly static int32  'CompareTo$cont@4-1'(class Match01/Test1 this,
+                                                      class Match01/Test1 objTemp,
                                                       class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
   {
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -1269,44 +1235,44 @@
     .maxstack  5
     .locals init (int32 V_0,
              int32 V_1,
-             class assembly/Test1/X11 V_2,
-             class assembly/Test1/X11 V_3,
+             class Match01/Test1/X11 V_2,
+             class Match01/Test1/X11 V_3,
              int32 V_4,
              int32 V_5,
-             class assembly/Test1/X12 V_6,
-             class assembly/Test1/X12 V_7,
-             class assembly/Test1/X13 V_8,
-             class assembly/Test1/X13 V_9,
-             class assembly/Test1/X14 V_10,
-             class assembly/Test1/X14 V_11)
+             class Match01/Test1/X12 V_6,
+             class Match01/Test1/X12 V_7,
+             class Match01/Test1/X13 V_8,
+             class Match01/Test1/X13 V_9,
+             class Match01/Test1/X14 V_10,
+             class Match01/Test1/X14 V_11)
     IL_0000:  ldarg.0
-    IL_0001:  ldfld      int32 assembly/Test1::_tag
+    IL_0001:  ldfld      int32 Match01/Test1::_tag
     IL_0006:  stloc.0
     IL_0007:  ldarg.1
-    IL_0008:  ldfld      int32 assembly/Test1::_tag
+    IL_0008:  ldfld      int32 Match01/Test1::_tag
     IL_000d:  stloc.1
     IL_000e:  ldloc.0
     IL_000f:  ldloc.1
     IL_0010:  bne.un     IL_00ec
 
     IL_0015:  ldarg.0
-    IL_0016:  call       instance int32 assembly/Test1::get_Tag()
+    IL_0016:  call       instance int32 Match01/Test1::get_Tag()
     IL_001b:  switch     ( 
                           IL_0030,
                           IL_005c,
                           IL_008c,
                           IL_00bc)
     IL_0030:  ldarg.0
-    IL_0031:  castclass  assembly/Test1/X11
+    IL_0031:  castclass  Match01/Test1/X11
     IL_0036:  stloc.2
     IL_0037:  ldarg.1
-    IL_0038:  castclass  assembly/Test1/X11
+    IL_0038:  castclass  Match01/Test1/X11
     IL_003d:  stloc.3
     IL_003e:  ldloc.2
-    IL_003f:  ldfld      int32 assembly/Test1/X11::item
+    IL_003f:  ldfld      int32 Match01/Test1/X11::item
     IL_0044:  stloc.s    V_4
     IL_0046:  ldloc.3
-    IL_0047:  ldfld      int32 assembly/Test1/X11::item
+    IL_0047:  ldfld      int32 Match01/Test1/X11::item
     IL_004c:  stloc.s    V_5
     IL_004e:  ldloc.s    V_4
     IL_0050:  ldloc.s    V_5
@@ -1318,16 +1284,16 @@
     IL_005b:  ret
 
     IL_005c:  ldarg.0
-    IL_005d:  castclass  assembly/Test1/X12
+    IL_005d:  castclass  Match01/Test1/X12
     IL_0062:  stloc.s    V_6
     IL_0064:  ldarg.1
-    IL_0065:  castclass  assembly/Test1/X12
+    IL_0065:  castclass  Match01/Test1/X12
     IL_006a:  stloc.s    V_7
     IL_006c:  ldloc.s    V_6
-    IL_006e:  ldfld      int32 assembly/Test1/X12::item
+    IL_006e:  ldfld      int32 Match01/Test1/X12::item
     IL_0073:  stloc.s    V_4
     IL_0075:  ldloc.s    V_7
-    IL_0077:  ldfld      int32 assembly/Test1/X12::item
+    IL_0077:  ldfld      int32 Match01/Test1/X12::item
     IL_007c:  stloc.s    V_5
     IL_007e:  ldloc.s    V_4
     IL_0080:  ldloc.s    V_5
@@ -1339,16 +1305,16 @@
     IL_008b:  ret
 
     IL_008c:  ldarg.0
-    IL_008d:  castclass  assembly/Test1/X13
+    IL_008d:  castclass  Match01/Test1/X13
     IL_0092:  stloc.s    V_8
     IL_0094:  ldarg.1
-    IL_0095:  castclass  assembly/Test1/X13
+    IL_0095:  castclass  Match01/Test1/X13
     IL_009a:  stloc.s    V_9
     IL_009c:  ldloc.s    V_8
-    IL_009e:  ldfld      int32 assembly/Test1/X13::item
+    IL_009e:  ldfld      int32 Match01/Test1/X13::item
     IL_00a3:  stloc.s    V_4
     IL_00a5:  ldloc.s    V_9
-    IL_00a7:  ldfld      int32 assembly/Test1/X13::item
+    IL_00a7:  ldfld      int32 Match01/Test1/X13::item
     IL_00ac:  stloc.s    V_5
     IL_00ae:  ldloc.s    V_4
     IL_00b0:  ldloc.s    V_5
@@ -1360,16 +1326,16 @@
     IL_00bb:  ret
 
     IL_00bc:  ldarg.0
-    IL_00bd:  castclass  assembly/Test1/X14
+    IL_00bd:  castclass  Match01/Test1/X14
     IL_00c2:  stloc.s    V_10
     IL_00c4:  ldarg.1
-    IL_00c5:  castclass  assembly/Test1/X14
+    IL_00c5:  castclass  Match01/Test1/X14
     IL_00ca:  stloc.s    V_11
     IL_00cc:  ldloc.s    V_10
-    IL_00ce:  ldfld      int32 assembly/Test1/X14::item
+    IL_00ce:  ldfld      int32 Match01/Test1/X14::item
     IL_00d3:  stloc.s    V_4
     IL_00d5:  ldloc.s    V_11
-    IL_00d7:  ldfld      int32 assembly/Test1/X14::item
+    IL_00d7:  ldfld      int32 Match01/Test1/X14::item
     IL_00dc:  stloc.s    V_5
     IL_00de:  ldloc.s    V_4
     IL_00e0:  ldloc.s    V_5
@@ -1386,21 +1352,21 @@
     IL_00ef:  ret
   } 
 
-  .method public static int32  select1(class assembly/Test1 x) cil managed
+  .method public static int32  select1(class Match01/Test1 x) cil managed
   {
     
     .maxstack  8
     IL_0000:  nop
     IL_0001:  ldarg.0
-    IL_0002:  call       instance int32 assembly/Test1::get_Tag()
+    IL_0002:  call       instance int32 Match01/Test1::get_Tag()
     IL_0007:  switch     ( 
                           IL_001c,
                           IL_0028,
                           IL_002a,
                           IL_002c)
     IL_001c:  ldarg.0
-    IL_001d:  castclass  assembly/Test1/X11
-    IL_0022:  ldfld      int32 assembly/Test1/X11::item
+    IL_001d:  castclass  Match01/Test1/X11
+    IL_0022:  ldfld      int32 Match01/Test1/X11::item
     IL_0027:  ret
 
     IL_0028:  ldc.i4.2
@@ -1413,18 +1379,18 @@
     IL_002d:  ret
   } 
 
-  .method public static int32  fm(class assembly/Test1 y) cil managed
+  .method public static int32  fm(class Match01/Test1 y) cil managed
   {
     
     .maxstack  8
     IL_0000:  ldarg.0
-    IL_0001:  call       int32 assembly::select1(class assembly/Test1)
+    IL_0001:  call       int32 Match01::select1(class Match01/Test1)
     IL_0006:  ret
   } 
 
 } 
 
-.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Match01
        extends [runtime]System.Object
 {
   .method public static void  main@() cil managed
@@ -1491,8 +1457,7 @@
     IL_0014:  ret
   } 
 
-  .method public hidebysig specialname instance class [runtime]System.Type 
-          get_Type() cil managed
+  .method public hidebysig specialname instance class [runtime]System.Type get_Type() cil managed
   {
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -1503,8 +1468,7 @@
     IL_0006:  ret
   } 
 
-  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes 
-          get_MemberType() cil managed
+  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes get_MemberType() cil managed
   {
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOff.fs.il.net472.release.bsl
similarity index 78%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOff.fs.il.net472.release.bsl
index 9b90e1ab7d1..f1f842db266 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01.fs.il.net472.release.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOff.fs.il.net472.release.bsl
@@ -39,15 +39,15 @@
 
 
 
-.class public abstract auto ansi sealed assembly
+.class public abstract auto ansi sealed Match01
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
   .class abstract auto autochar serializable nested public beforefieldinit Test1
          extends [runtime]System.Object
-         implements class [runtime]System.IEquatable`1<class assembly/Test1>,
+         implements class [runtime]System.IEquatable`1<class Match01/Test1>,
                     [runtime]System.Collections.IStructuralEquatable,
-                    class [runtime]System.IComparable`1<class assembly/Test1>,
+                    class [runtime]System.IComparable`1<class Match01/Test1>,
                     [runtime]System.IComparable,
                     [runtime]System.Collections.IStructuralComparable
   {
@@ -64,7 +64,7 @@
     } 
 
     .class auto ansi serializable nested public beforefieldinit specialname X11
-           extends assembly/Test1
+           extends Match01/Test1
     {
       .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
                                                                                                                             2B 58 31 31 40 44 65 62 75 67 54 79 70 65 50 72   
@@ -75,8 +75,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(int32 item) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
       {
         .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -87,22 +86,21 @@
         .maxstack  8
         IL_0000:  ldarg.0
         IL_0001:  ldc.i4.0
-        IL_0002:  call       instance void assembly/Test1::.ctor(int32)
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
         IL_0007:  ldarg.0
         IL_0008:  ldarg.1
-        IL_0009:  stfld      int32 assembly/Test1/X11::item
+        IL_0009:  stfld      int32 Match01/Test1/X11::item
         IL_000e:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      int32 assembly/Test1/X11::item
+        IL_0001:  ldfld      int32 Match01/Test1/X11::item
         IL_0006:  ret
       } 
 
@@ -113,12 +111,12 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X11::get_Item()
+        .get instance int32 Match01/Test1/X11::get_Item()
       } 
     } 
 
     .class auto ansi serializable nested public beforefieldinit specialname X12
-           extends assembly/Test1
+           extends Match01/Test1
     {
       .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
                                                                                                                             2B 58 31 32 40 44 65 62 75 67 54 79 70 65 50 72   
@@ -129,8 +127,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(int32 item) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
       {
         .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -141,22 +138,21 @@
         .maxstack  8
         IL_0000:  ldarg.0
         IL_0001:  ldc.i4.1
-        IL_0002:  call       instance void assembly/Test1::.ctor(int32)
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
         IL_0007:  ldarg.0
         IL_0008:  ldarg.1
-        IL_0009:  stfld      int32 assembly/Test1/X12::item
+        IL_0009:  stfld      int32 Match01/Test1/X12::item
         IL_000e:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      int32 assembly/Test1/X12::item
+        IL_0001:  ldfld      int32 Match01/Test1/X12::item
         IL_0006:  ret
       } 
 
@@ -167,12 +163,12 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 01 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X12::get_Item()
+        .get instance int32 Match01/Test1/X12::get_Item()
       } 
     } 
 
     .class auto ansi serializable nested public beforefieldinit specialname X13
-           extends assembly/Test1
+           extends Match01/Test1
     {
       .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
                                                                                                                             2B 58 31 33 40 44 65 62 75 67 54 79 70 65 50 72   
@@ -183,8 +179,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(int32 item) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
       {
         .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -195,22 +190,21 @@
         .maxstack  8
         IL_0000:  ldarg.0
         IL_0001:  ldc.i4.2
-        IL_0002:  call       instance void assembly/Test1::.ctor(int32)
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
         IL_0007:  ldarg.0
         IL_0008:  ldarg.1
-        IL_0009:  stfld      int32 assembly/Test1/X13::item
+        IL_0009:  stfld      int32 Match01/Test1/X13::item
         IL_000e:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      int32 assembly/Test1/X13::item
+        IL_0001:  ldfld      int32 Match01/Test1/X13::item
         IL_0006:  ret
       } 
 
@@ -221,12 +215,12 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 02 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X13::get_Item()
+        .get instance int32 Match01/Test1/X13::get_Item()
       } 
     } 
 
     .class auto ansi serializable nested public beforefieldinit specialname X14
-           extends assembly/Test1
+           extends Match01/Test1
     {
       .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
                                                                                                                             2B 58 31 34 40 44 65 62 75 67 54 79 70 65 50 72   
@@ -237,8 +231,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(int32 item) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
       {
         .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -249,22 +242,21 @@
         .maxstack  8
         IL_0000:  ldarg.0
         IL_0001:  ldc.i4.3
-        IL_0002:  call       instance void assembly/Test1::.ctor(int32)
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
         IL_0007:  ldarg.0
         IL_0008:  ldarg.1
-        IL_0009:  stfld      int32 assembly/Test1/X14::item
+        IL_0009:  stfld      int32 Match01/Test1/X14::item
         IL_000e:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      int32 assembly/Test1/X14::item
+        IL_0001:  ldfld      int32 Match01/Test1/X14::item
         IL_0006:  ret
       } 
 
@@ -275,19 +267,18 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 03 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X14::get_Item()
+        .get instance int32 Match01/Test1/X14::get_Item()
       } 
     } 
 
     .class auto ansi nested assembly beforefieldinit specialname X11@DebugTypeProxy
            extends [runtime]System.Object
     {
-      .field assembly class assembly/Test1/X11 _obj
+      .field assembly class Match01/Test1/X11 _obj
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method public specialname rtspecialname 
-              instance void  .ctor(class assembly/Test1/X11 obj) cil managed
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X11 obj) cil managed
       {
         .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -300,20 +291,19 @@
         IL_0001:  call       instance void [runtime]System.Object::.ctor()
         IL_0006:  ldarg.0
         IL_0007:  ldarg.1
-        IL_0008:  stfld      class assembly/Test1/X11 assembly/Test1/X11@DebugTypeProxy::_obj
+        IL_0008:  stfld      class Match01/Test1/X11 Match01/Test1/X11@DebugTypeProxy::_obj
         IL_000d:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      class assembly/Test1/X11 assembly/Test1/X11@DebugTypeProxy::_obj
-        IL_0006:  ldfld      int32 assembly/Test1/X11::item
+        IL_0001:  ldfld      class Match01/Test1/X11 Match01/Test1/X11@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X11::item
         IL_000b:  ret
       } 
 
@@ -324,19 +314,18 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X11@DebugTypeProxy::get_Item()
+        .get instance int32 Match01/Test1/X11@DebugTypeProxy::get_Item()
       } 
     } 
 
     .class auto ansi nested assembly beforefieldinit specialname X12@DebugTypeProxy
            extends [runtime]System.Object
     {
-      .field assembly class assembly/Test1/X12 _obj
+      .field assembly class Match01/Test1/X12 _obj
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method public specialname rtspecialname 
-              instance void  .ctor(class assembly/Test1/X12 obj) cil managed
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X12 obj) cil managed
       {
         .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -349,20 +338,19 @@
         IL_0001:  call       instance void [runtime]System.Object::.ctor()
         IL_0006:  ldarg.0
         IL_0007:  ldarg.1
-        IL_0008:  stfld      class assembly/Test1/X12 assembly/Test1/X12@DebugTypeProxy::_obj
+        IL_0008:  stfld      class Match01/Test1/X12 Match01/Test1/X12@DebugTypeProxy::_obj
         IL_000d:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      class assembly/Test1/X12 assembly/Test1/X12@DebugTypeProxy::_obj
-        IL_0006:  ldfld      int32 assembly/Test1/X12::item
+        IL_0001:  ldfld      class Match01/Test1/X12 Match01/Test1/X12@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X12::item
         IL_000b:  ret
       } 
 
@@ -373,19 +361,18 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 01 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X12@DebugTypeProxy::get_Item()
+        .get instance int32 Match01/Test1/X12@DebugTypeProxy::get_Item()
       } 
     } 
 
     .class auto ansi nested assembly beforefieldinit specialname X13@DebugTypeProxy
            extends [runtime]System.Object
     {
-      .field assembly class assembly/Test1/X13 _obj
+      .field assembly class Match01/Test1/X13 _obj
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method public specialname rtspecialname 
-              instance void  .ctor(class assembly/Test1/X13 obj) cil managed
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X13 obj) cil managed
       {
         .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -398,20 +385,19 @@
         IL_0001:  call       instance void [runtime]System.Object::.ctor()
         IL_0006:  ldarg.0
         IL_0007:  ldarg.1
-        IL_0008:  stfld      class assembly/Test1/X13 assembly/Test1/X13@DebugTypeProxy::_obj
+        IL_0008:  stfld      class Match01/Test1/X13 Match01/Test1/X13@DebugTypeProxy::_obj
         IL_000d:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      class assembly/Test1/X13 assembly/Test1/X13@DebugTypeProxy::_obj
-        IL_0006:  ldfld      int32 assembly/Test1/X13::item
+        IL_0001:  ldfld      class Match01/Test1/X13 Match01/Test1/X13@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X13::item
         IL_000b:  ret
       } 
 
@@ -422,19 +408,18 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 02 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X13@DebugTypeProxy::get_Item()
+        .get instance int32 Match01/Test1/X13@DebugTypeProxy::get_Item()
       } 
     } 
 
     .class auto ansi nested assembly beforefieldinit specialname X14@DebugTypeProxy
            extends [runtime]System.Object
     {
-      .field assembly class assembly/Test1/X14 _obj
+      .field assembly class Match01/Test1/X14 _obj
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method public specialname rtspecialname 
-              instance void  .ctor(class assembly/Test1/X14 obj) cil managed
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X14 obj) cil managed
       {
         .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -447,20 +432,19 @@
         IL_0001:  call       instance void [runtime]System.Object::.ctor()
         IL_0006:  ldarg.0
         IL_0007:  ldarg.1
-        IL_0008:  stfld      class assembly/Test1/X14 assembly/Test1/X14@DebugTypeProxy::_obj
+        IL_0008:  stfld      class Match01/Test1/X14 Match01/Test1/X14@DebugTypeProxy::_obj
         IL_000d:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      class assembly/Test1/X14 assembly/Test1/X14@DebugTypeProxy::_obj
-        IL_0006:  ldfld      int32 assembly/Test1/X14::item
+        IL_0001:  ldfld      class Match01/Test1/X14 Match01/Test1/X14@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X14::item
         IL_000b:  ret
       } 
 
@@ -471,7 +455,7 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 03 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X14@DebugTypeProxy::get_Item()
+        .get instance int32 Match01/Test1/X14@DebugTypeProxy::get_Item()
       } 
     } 
 
@@ -479,8 +463,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(int32 _tag) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(int32 _tag) cil managed
     {
       .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                               class [runtime]System.Type) = ( 01 00 E0 07 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -493,157 +476,145 @@
       IL_0001:  call       instance void [runtime]System.Object::.ctor()
       IL_0006:  ldarg.0
       IL_0007:  ldarg.1
-      IL_0008:  stfld      int32 assembly/Test1::_tag
+      IL_0008:  stfld      int32 Match01/Test1::_tag
       IL_000d:  ret
     } 
 
-    .method public static class assembly/Test1 
-            NewX11(int32 item) cil managed
+    .method public static class Match01/Test1 NewX11(int32 item) cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  newobj     instance void assembly/Test1/X11::.ctor(int32)
+      IL_0001:  newobj     instance void Match01/Test1/X11::.ctor(int32)
       IL_0006:  ret
     } 
 
-    .method public hidebysig instance bool 
-            get_IsX11() cil managed
+    .method public hidebysig instance bool get_IsX11() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
       IL_0006:  ldc.i4.0
       IL_0007:  ceq
       IL_0009:  ret
     } 
 
-    .method public static class assembly/Test1 
-            NewX12(int32 item) cil managed
+    .method public static class Match01/Test1 NewX12(int32 item) cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 01 00 00 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  newobj     instance void assembly/Test1/X12::.ctor(int32)
+      IL_0001:  newobj     instance void Match01/Test1/X12::.ctor(int32)
       IL_0006:  ret
     } 
 
-    .method public hidebysig instance bool 
-            get_IsX12() cil managed
+    .method public hidebysig instance bool get_IsX12() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
       IL_0006:  ldc.i4.1
       IL_0007:  ceq
       IL_0009:  ret
     } 
 
-    .method public static class assembly/Test1 
-            NewX13(int32 item) cil managed
+    .method public static class Match01/Test1 NewX13(int32 item) cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 02 00 00 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  newobj     instance void assembly/Test1/X13::.ctor(int32)
+      IL_0001:  newobj     instance void Match01/Test1/X13::.ctor(int32)
       IL_0006:  ret
     } 
 
-    .method public hidebysig instance bool 
-            get_IsX13() cil managed
+    .method public hidebysig instance bool get_IsX13() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
       IL_0006:  ldc.i4.2
       IL_0007:  ceq
       IL_0009:  ret
     } 
 
-    .method public static class assembly/Test1 
-            NewX14(int32 item) cil managed
+    .method public static class Match01/Test1 NewX14(int32 item) cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 03 00 00 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  newobj     instance void assembly/Test1/X14::.ctor(int32)
+      IL_0001:  newobj     instance void Match01/Test1/X14::.ctor(int32)
       IL_0006:  ret
     } 
 
-    .method public hidebysig instance bool 
-            get_IsX14() cil managed
+    .method public hidebysig instance bool get_IsX14() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
       IL_0006:  ldc.i4.3
       IL_0007:  ceq
       IL_0009:  ret
     } 
 
-    .method public hidebysig instance int32 
-            get_Tag() cil managed
+    .method public hidebysig instance int32 get_Tag() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  ldfld      int32 assembly/Test1::_tag
+      IL_0001:  ldfld      int32 Match01/Test1::_tag
       IL_0006:  ret
     } 
 
-    .method assembly hidebysig specialname 
-            instance object  __DebugDisplay() cil managed
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldstr      "%+0.8A"
-      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
-      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
       IL_000f:  ldarg.0
-      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>::Invoke(!0)
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>::Invoke(!0)
       IL_0015:  ret
     } 
 
-    .method public strict virtual instance string 
-            ToString() cil managed
+    .method public strict virtual instance string ToString() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldstr      "%+A"
-      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class assembly/Test1>::.ctor(string)
-      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class Match01/Test1>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
       IL_000f:  ldarg.0
-      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>::Invoke(!0)
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>::Invoke(!0)
       IL_0015:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(class assembly/Test1 obj) cil managed
+    .method public hidebysig virtual final instance int32  CompareTo(class Match01/Test1 obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -657,8 +628,8 @@
       IL_0006:  ldarg.0
       IL_0007:  ldarg.1
       IL_0008:  ldnull
-      IL_0009:  call       int32 assembly::CompareTo$cont@4(class assembly/Test1,
-                                                           class assembly/Test1,
+      IL_0009:  call       int32 Match01::CompareTo$cont@4(class Match01/Test1,
+                                                           class Match01/Test1,
                                                            class [FSharp.Core]Microsoft.FSharp.Core.Unit)
       IL_000e:  ret
 
@@ -675,16 +646,15 @@
       IL_0017:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(object obj) cil managed
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
       IL_0001:  ldarg.1
-      IL_0002:  unbox.any  assembly/Test1
-      IL_0007:  callvirt   instance int32 assembly/Test1::CompareTo(class assembly/Test1)
+      IL_0002:  unbox.any  Match01/Test1
+      IL_0007:  callvirt   instance int32 Match01/Test1::CompareTo(class Match01/Test1)
       IL_000c:  ret
     } 
 
@@ -695,9 +665,9 @@
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  6
-      .locals init (class assembly/Test1 V_0)
+      .locals init (class Match01/Test1 V_0)
       IL_0000:  ldarg.1
-      IL_0001:  unbox.any  assembly/Test1
+      IL_0001:  unbox.any  Match01/Test1
       IL_0006:  stloc.0
       IL_0007:  ldarg.0
       IL_0008:  brfalse.s  IL_0014
@@ -706,14 +676,14 @@
       IL_000b:  ldarg.1
       IL_000c:  ldloc.0
       IL_000d:  ldnull
-      IL_000e:  call       int32 assembly::'CompareTo$cont@4-1'(class assembly/Test1,
+      IL_000e:  call       int32 Match01::'CompareTo$cont@4-1'(class Match01/Test1,
                                                                object,
-                                                               class assembly/Test1,
+                                                               class Match01/Test1,
                                                                class [FSharp.Core]Microsoft.FSharp.Core.Unit)
       IL_0013:  ret
 
       IL_0014:  ldarg.1
-      IL_0015:  unbox.any  assembly/Test1
+      IL_0015:  unbox.any  Match01/Test1
       IL_001a:  brfalse.s  IL_001e
 
       IL_001c:  ldc.i4.m1
@@ -723,37 +693,36 @@
       IL_001f:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  7
       .locals init (int32 V_0,
-               class assembly/Test1/X11 V_1,
-               class assembly/Test1/X12 V_2,
-               class assembly/Test1/X13 V_3,
-               class assembly/Test1/X14 V_4)
+               class Match01/Test1/X11 V_1,
+               class Match01/Test1/X12 V_2,
+               class Match01/Test1/X13 V_3,
+               class Match01/Test1/X14 V_4)
       IL_0000:  ldarg.0
       IL_0001:  brfalse    IL_00a5
 
       IL_0006:  ldc.i4.0
       IL_0007:  stloc.0
       IL_0008:  ldarg.0
-      IL_0009:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0009:  call       instance int32 Match01/Test1::get_Tag()
       IL_000e:  switch     ( 
                             IL_0023,
                             IL_0043,
                             IL_0063,
                             IL_0083)
       IL_0023:  ldarg.0
-      IL_0024:  castclass  assembly/Test1/X11
+      IL_0024:  castclass  Match01/Test1/X11
       IL_0029:  stloc.1
       IL_002a:  ldc.i4.0
       IL_002b:  stloc.0
       IL_002c:  ldc.i4     0x9e3779b9
       IL_0031:  ldloc.1
-      IL_0032:  ldfld      int32 assembly/Test1/X11::item
+      IL_0032:  ldfld      int32 Match01/Test1/X11::item
       IL_0037:  ldloc.0
       IL_0038:  ldc.i4.6
       IL_0039:  shl
@@ -768,13 +737,13 @@
       IL_0042:  ret
 
       IL_0043:  ldarg.0
-      IL_0044:  castclass  assembly/Test1/X12
+      IL_0044:  castclass  Match01/Test1/X12
       IL_0049:  stloc.2
       IL_004a:  ldc.i4.1
       IL_004b:  stloc.0
       IL_004c:  ldc.i4     0x9e3779b9
       IL_0051:  ldloc.2
-      IL_0052:  ldfld      int32 assembly/Test1/X12::item
+      IL_0052:  ldfld      int32 Match01/Test1/X12::item
       IL_0057:  ldloc.0
       IL_0058:  ldc.i4.6
       IL_0059:  shl
@@ -789,13 +758,13 @@
       IL_0062:  ret
 
       IL_0063:  ldarg.0
-      IL_0064:  castclass  assembly/Test1/X13
+      IL_0064:  castclass  Match01/Test1/X13
       IL_0069:  stloc.3
       IL_006a:  ldc.i4.2
       IL_006b:  stloc.0
       IL_006c:  ldc.i4     0x9e3779b9
       IL_0071:  ldloc.3
-      IL_0072:  ldfld      int32 assembly/Test1/X13::item
+      IL_0072:  ldfld      int32 Match01/Test1/X13::item
       IL_0077:  ldloc.0
       IL_0078:  ldc.i4.6
       IL_0079:  shl
@@ -810,13 +779,13 @@
       IL_0082:  ret
 
       IL_0083:  ldarg.0
-      IL_0084:  castclass  assembly/Test1/X14
+      IL_0084:  castclass  Match01/Test1/X14
       IL_0089:  stloc.s    V_4
       IL_008b:  ldc.i4.3
       IL_008c:  stloc.0
       IL_008d:  ldc.i4     0x9e3779b9
       IL_0092:  ldloc.s    V_4
-      IL_0094:  ldfld      int32 assembly/Test1/X14::item
+      IL_0094:  ldfld      int32 Match01/Test1/X14::item
       IL_0099:  ldloc.0
       IL_009a:  ldc.i4.6
       IL_009b:  shl
@@ -834,15 +803,14 @@
       IL_00a6:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode() cil managed
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
       IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
-      IL_0006:  callvirt   instance int32 assembly/Test1::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_0006:  callvirt   instance int32 Match01/Test1::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
       IL_000b:  ret
     } 
 
@@ -853,92 +821,92 @@
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  4
-      .locals init (class assembly/Test1 V_0,
+      .locals init (class Match01/Test1 V_0,
                int32 V_1,
                int32 V_2,
-               class assembly/Test1/X11 V_3,
-               class assembly/Test1/X11 V_4,
-               class assembly/Test1/X12 V_5,
-               class assembly/Test1/X12 V_6,
-               class assembly/Test1/X13 V_7,
-               class assembly/Test1/X13 V_8,
-               class assembly/Test1/X14 V_9,
-               class assembly/Test1/X14 V_10)
+               class Match01/Test1/X11 V_3,
+               class Match01/Test1/X11 V_4,
+               class Match01/Test1/X12 V_5,
+               class Match01/Test1/X12 V_6,
+               class Match01/Test1/X13 V_7,
+               class Match01/Test1/X13 V_8,
+               class Match01/Test1/X14 V_9,
+               class Match01/Test1/X14 V_10)
       IL_0000:  ldarg.0
       IL_0001:  brfalse    IL_00c9
 
       IL_0006:  ldarg.1
-      IL_0007:  isinst     assembly/Test1
+      IL_0007:  isinst     Match01/Test1
       IL_000c:  stloc.0
       IL_000d:  ldloc.0
       IL_000e:  brfalse    IL_00c7
 
       IL_0013:  ldarg.0
-      IL_0014:  ldfld      int32 assembly/Test1::_tag
+      IL_0014:  ldfld      int32 Match01/Test1::_tag
       IL_0019:  stloc.1
       IL_001a:  ldloc.0
-      IL_001b:  ldfld      int32 assembly/Test1::_tag
+      IL_001b:  ldfld      int32 Match01/Test1::_tag
       IL_0020:  stloc.2
       IL_0021:  ldloc.1
       IL_0022:  ldloc.2
       IL_0023:  bne.un     IL_00c5
 
       IL_0028:  ldarg.0
-      IL_0029:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0029:  call       instance int32 Match01/Test1::get_Tag()
       IL_002e:  switch     ( 
                             IL_0043,
                             IL_0062,
                             IL_0083,
                             IL_00a4)
       IL_0043:  ldarg.0
-      IL_0044:  castclass  assembly/Test1/X11
+      IL_0044:  castclass  Match01/Test1/X11
       IL_0049:  stloc.3
       IL_004a:  ldloc.0
-      IL_004b:  castclass  assembly/Test1/X11
+      IL_004b:  castclass  Match01/Test1/X11
       IL_0050:  stloc.s    V_4
       IL_0052:  ldloc.3
-      IL_0053:  ldfld      int32 assembly/Test1/X11::item
+      IL_0053:  ldfld      int32 Match01/Test1/X11::item
       IL_0058:  ldloc.s    V_4
-      IL_005a:  ldfld      int32 assembly/Test1/X11::item
+      IL_005a:  ldfld      int32 Match01/Test1/X11::item
       IL_005f:  ceq
       IL_0061:  ret
 
       IL_0062:  ldarg.0
-      IL_0063:  castclass  assembly/Test1/X12
+      IL_0063:  castclass  Match01/Test1/X12
       IL_0068:  stloc.s    V_5
       IL_006a:  ldloc.0
-      IL_006b:  castclass  assembly/Test1/X12
+      IL_006b:  castclass  Match01/Test1/X12
       IL_0070:  stloc.s    V_6
       IL_0072:  ldloc.s    V_5
-      IL_0074:  ldfld      int32 assembly/Test1/X12::item
+      IL_0074:  ldfld      int32 Match01/Test1/X12::item
       IL_0079:  ldloc.s    V_6
-      IL_007b:  ldfld      int32 assembly/Test1/X12::item
+      IL_007b:  ldfld      int32 Match01/Test1/X12::item
       IL_0080:  ceq
       IL_0082:  ret
 
       IL_0083:  ldarg.0
-      IL_0084:  castclass  assembly/Test1/X13
+      IL_0084:  castclass  Match01/Test1/X13
       IL_0089:  stloc.s    V_7
       IL_008b:  ldloc.0
-      IL_008c:  castclass  assembly/Test1/X13
+      IL_008c:  castclass  Match01/Test1/X13
       IL_0091:  stloc.s    V_8
       IL_0093:  ldloc.s    V_7
-      IL_0095:  ldfld      int32 assembly/Test1/X13::item
+      IL_0095:  ldfld      int32 Match01/Test1/X13::item
       IL_009a:  ldloc.s    V_8
-      IL_009c:  ldfld      int32 assembly/Test1/X13::item
+      IL_009c:  ldfld      int32 Match01/Test1/X13::item
       IL_00a1:  ceq
       IL_00a3:  ret
 
       IL_00a4:  ldarg.0
-      IL_00a5:  castclass  assembly/Test1/X14
+      IL_00a5:  castclass  Match01/Test1/X14
       IL_00aa:  stloc.s    V_9
       IL_00ac:  ldloc.0
-      IL_00ad:  castclass  assembly/Test1/X14
+      IL_00ad:  castclass  Match01/Test1/X14
       IL_00b2:  stloc.s    V_10
       IL_00b4:  ldloc.s    V_9
-      IL_00b6:  ldfld      int32 assembly/Test1/X14::item
+      IL_00b6:  ldfld      int32 Match01/Test1/X14::item
       IL_00bb:  ldloc.s    V_10
-      IL_00bd:  ldfld      int32 assembly/Test1/X14::item
+      IL_00bd:  ldfld      int32 Match01/Test1/X14::item
       IL_00c2:  ceq
       IL_00c4:  ret
 
@@ -956,22 +924,21 @@
       IL_00d0:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance bool  Equals(class assembly/Test1 obj) cil managed
+    .method public hidebysig virtual final instance bool  Equals(class Match01/Test1 obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  4
       .locals init (int32 V_0,
                int32 V_1,
-               class assembly/Test1/X11 V_2,
-               class assembly/Test1/X11 V_3,
-               class assembly/Test1/X12 V_4,
-               class assembly/Test1/X12 V_5,
-               class assembly/Test1/X13 V_6,
-               class assembly/Test1/X13 V_7,
-               class assembly/Test1/X14 V_8,
-               class assembly/Test1/X14 V_9)
+               class Match01/Test1/X11 V_2,
+               class Match01/Test1/X11 V_3,
+               class Match01/Test1/X12 V_4,
+               class Match01/Test1/X12 V_5,
+               class Match01/Test1/X13 V_6,
+               class Match01/Test1/X13 V_7,
+               class Match01/Test1/X14 V_8,
+               class Match01/Test1/X14 V_9)
       IL_0000:  ldarg.0
       IL_0001:  brfalse    IL_00c0
 
@@ -979,71 +946,71 @@
       IL_0007:  brfalse    IL_00be
 
       IL_000c:  ldarg.0
-      IL_000d:  ldfld      int32 assembly/Test1::_tag
+      IL_000d:  ldfld      int32 Match01/Test1::_tag
       IL_0012:  stloc.0
       IL_0013:  ldarg.1
-      IL_0014:  ldfld      int32 assembly/Test1::_tag
+      IL_0014:  ldfld      int32 Match01/Test1::_tag
       IL_0019:  stloc.1
       IL_001a:  ldloc.0
       IL_001b:  ldloc.1
       IL_001c:  bne.un     IL_00bc
 
       IL_0021:  ldarg.0
-      IL_0022:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0022:  call       instance int32 Match01/Test1::get_Tag()
       IL_0027:  switch     ( 
                             IL_003c,
                             IL_0059,
                             IL_007a,
                             IL_009b)
       IL_003c:  ldarg.0
-      IL_003d:  castclass  assembly/Test1/X11
+      IL_003d:  castclass  Match01/Test1/X11
       IL_0042:  stloc.2
       IL_0043:  ldarg.1
-      IL_0044:  castclass  assembly/Test1/X11
+      IL_0044:  castclass  Match01/Test1/X11
       IL_0049:  stloc.3
       IL_004a:  ldloc.2
-      IL_004b:  ldfld      int32 assembly/Test1/X11::item
+      IL_004b:  ldfld      int32 Match01/Test1/X11::item
       IL_0050:  ldloc.3
-      IL_0051:  ldfld      int32 assembly/Test1/X11::item
+      IL_0051:  ldfld      int32 Match01/Test1/X11::item
       IL_0056:  ceq
       IL_0058:  ret
 
       IL_0059:  ldarg.0
-      IL_005a:  castclass  assembly/Test1/X12
+      IL_005a:  castclass  Match01/Test1/X12
       IL_005f:  stloc.s    V_4
       IL_0061:  ldarg.1
-      IL_0062:  castclass  assembly/Test1/X12
+      IL_0062:  castclass  Match01/Test1/X12
       IL_0067:  stloc.s    V_5
       IL_0069:  ldloc.s    V_4
-      IL_006b:  ldfld      int32 assembly/Test1/X12::item
+      IL_006b:  ldfld      int32 Match01/Test1/X12::item
       IL_0070:  ldloc.s    V_5
-      IL_0072:  ldfld      int32 assembly/Test1/X12::item
+      IL_0072:  ldfld      int32 Match01/Test1/X12::item
       IL_0077:  ceq
       IL_0079:  ret
 
       IL_007a:  ldarg.0
-      IL_007b:  castclass  assembly/Test1/X13
+      IL_007b:  castclass  Match01/Test1/X13
       IL_0080:  stloc.s    V_6
       IL_0082:  ldarg.1
-      IL_0083:  castclass  assembly/Test1/X13
+      IL_0083:  castclass  Match01/Test1/X13
       IL_0088:  stloc.s    V_7
       IL_008a:  ldloc.s    V_6
-      IL_008c:  ldfld      int32 assembly/Test1/X13::item
+      IL_008c:  ldfld      int32 Match01/Test1/X13::item
       IL_0091:  ldloc.s    V_7
-      IL_0093:  ldfld      int32 assembly/Test1/X13::item
+      IL_0093:  ldfld      int32 Match01/Test1/X13::item
       IL_0098:  ceq
       IL_009a:  ret
 
       IL_009b:  ldarg.0
-      IL_009c:  castclass  assembly/Test1/X14
+      IL_009c:  castclass  Match01/Test1/X14
       IL_00a1:  stloc.s    V_8
       IL_00a3:  ldarg.1
-      IL_00a4:  castclass  assembly/Test1/X14
+      IL_00a4:  castclass  Match01/Test1/X14
       IL_00a9:  stloc.s    V_9
       IL_00ab:  ldloc.s    V_8
-      IL_00ad:  ldfld      int32 assembly/Test1/X14::item
+      IL_00ad:  ldfld      int32 Match01/Test1/X14::item
       IL_00b2:  ldloc.s    V_9
-      IL_00b4:  ldfld      int32 assembly/Test1/X14::item
+      IL_00b4:  ldfld      int32 Match01/Test1/X14::item
       IL_00b9:  ceq
       IL_00bb:  ret
 
@@ -1061,22 +1028,21 @@
       IL_00c7:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance bool  Equals(object obj) cil managed
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  4
-      .locals init (class assembly/Test1 V_0)
+      .locals init (class Match01/Test1 V_0)
       IL_0000:  ldarg.1
-      IL_0001:  isinst     assembly/Test1
+      IL_0001:  isinst     Match01/Test1
       IL_0006:  stloc.0
       IL_0007:  ldloc.0
       IL_0008:  brfalse.s  IL_0012
 
       IL_000a:  ldarg.0
       IL_000b:  ldloc.0
-      IL_000c:  callvirt   instance bool assembly/Test1::Equals(class assembly/Test1)
+      IL_000c:  callvirt   instance bool Match01/Test1::Equals(class Match01/Test1)
       IL_0011:  ret
 
       IL_0012:  ldc.i4.0
@@ -1088,40 +1054,40 @@
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance int32 assembly/Test1::get_Tag()
+      .get instance int32 Match01/Test1::get_Tag()
     } 
     .property instance bool IsX11()
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance bool assembly/Test1::get_IsX11()
+      .get instance bool Match01/Test1::get_IsX11()
     } 
     .property instance bool IsX12()
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance bool assembly/Test1::get_IsX12()
+      .get instance bool Match01/Test1::get_IsX12()
     } 
     .property instance bool IsX13()
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance bool assembly/Test1::get_IsX13()
+      .get instance bool Match01/Test1::get_IsX13()
     } 
     .property instance bool IsX14()
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance bool assembly/Test1::get_IsX14()
+      .get instance bool Match01/Test1::get_IsX14()
     } 
   } 
 
-  .method assembly static int32  CompareTo$cont@4(class assembly/Test1 this,
-                                                  class assembly/Test1 obj,
+  .method assembly static int32  CompareTo$cont@4(class Match01/Test1 this,
+                                                  class Match01/Test1 obj,
                                                   class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
   {
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -1129,47 +1095,47 @@
     .maxstack  5
     .locals init (int32 V_0,
              int32 V_1,
-             class assembly/Test1/X11 V_2,
-             class assembly/Test1/X11 V_3,
+             class Match01/Test1/X11 V_2,
+             class Match01/Test1/X11 V_3,
              class [runtime]System.Collections.IComparer V_4,
              int32 V_5,
              int32 V_6,
-             class assembly/Test1/X12 V_7,
-             class assembly/Test1/X12 V_8,
-             class assembly/Test1/X13 V_9,
-             class assembly/Test1/X13 V_10,
-             class assembly/Test1/X14 V_11,
-             class assembly/Test1/X14 V_12)
+             class Match01/Test1/X12 V_7,
+             class Match01/Test1/X12 V_8,
+             class Match01/Test1/X13 V_9,
+             class Match01/Test1/X13 V_10,
+             class Match01/Test1/X14 V_11,
+             class Match01/Test1/X14 V_12)
     IL_0000:  ldarg.0
-    IL_0001:  ldfld      int32 assembly/Test1::_tag
+    IL_0001:  ldfld      int32 Match01/Test1::_tag
     IL_0006:  stloc.0
     IL_0007:  ldarg.1
-    IL_0008:  ldfld      int32 assembly/Test1::_tag
+    IL_0008:  ldfld      int32 Match01/Test1::_tag
     IL_000d:  stloc.1
     IL_000e:  ldloc.0
     IL_000f:  ldloc.1
     IL_0010:  bne.un     IL_0108
 
     IL_0015:  ldarg.0
-    IL_0016:  call       instance int32 assembly/Test1::get_Tag()
+    IL_0016:  call       instance int32 Match01/Test1::get_Tag()
     IL_001b:  switch     ( 
                           IL_0030,
                           IL_0063,
                           IL_009a,
                           IL_00d1)
     IL_0030:  ldarg.0
-    IL_0031:  castclass  assembly/Test1/X11
+    IL_0031:  castclass  Match01/Test1/X11
     IL_0036:  stloc.2
     IL_0037:  ldarg.1
-    IL_0038:  castclass  assembly/Test1/X11
+    IL_0038:  castclass  Match01/Test1/X11
     IL_003d:  stloc.3
     IL_003e:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
     IL_0043:  stloc.s    V_4
     IL_0045:  ldloc.2
-    IL_0046:  ldfld      int32 assembly/Test1/X11::item
+    IL_0046:  ldfld      int32 Match01/Test1/X11::item
     IL_004b:  stloc.s    V_5
     IL_004d:  ldloc.3
-    IL_004e:  ldfld      int32 assembly/Test1/X11::item
+    IL_004e:  ldfld      int32 Match01/Test1/X11::item
     IL_0053:  stloc.s    V_6
     IL_0055:  ldloc.s    V_5
     IL_0057:  ldloc.s    V_6
@@ -1181,18 +1147,18 @@
     IL_0062:  ret
 
     IL_0063:  ldarg.0
-    IL_0064:  castclass  assembly/Test1/X12
+    IL_0064:  castclass  Match01/Test1/X12
     IL_0069:  stloc.s    V_7
     IL_006b:  ldarg.1
-    IL_006c:  castclass  assembly/Test1/X12
+    IL_006c:  castclass  Match01/Test1/X12
     IL_0071:  stloc.s    V_8
     IL_0073:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
     IL_0078:  stloc.s    V_4
     IL_007a:  ldloc.s    V_7
-    IL_007c:  ldfld      int32 assembly/Test1/X12::item
+    IL_007c:  ldfld      int32 Match01/Test1/X12::item
     IL_0081:  stloc.s    V_5
     IL_0083:  ldloc.s    V_8
-    IL_0085:  ldfld      int32 assembly/Test1/X12::item
+    IL_0085:  ldfld      int32 Match01/Test1/X12::item
     IL_008a:  stloc.s    V_6
     IL_008c:  ldloc.s    V_5
     IL_008e:  ldloc.s    V_6
@@ -1204,18 +1170,18 @@
     IL_0099:  ret
 
     IL_009a:  ldarg.0
-    IL_009b:  castclass  assembly/Test1/X13
+    IL_009b:  castclass  Match01/Test1/X13
     IL_00a0:  stloc.s    V_9
     IL_00a2:  ldarg.1
-    IL_00a3:  castclass  assembly/Test1/X13
+    IL_00a3:  castclass  Match01/Test1/X13
     IL_00a8:  stloc.s    V_10
     IL_00aa:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
     IL_00af:  stloc.s    V_4
     IL_00b1:  ldloc.s    V_9
-    IL_00b3:  ldfld      int32 assembly/Test1/X13::item
+    IL_00b3:  ldfld      int32 Match01/Test1/X13::item
     IL_00b8:  stloc.s    V_5
     IL_00ba:  ldloc.s    V_10
-    IL_00bc:  ldfld      int32 assembly/Test1/X13::item
+    IL_00bc:  ldfld      int32 Match01/Test1/X13::item
     IL_00c1:  stloc.s    V_6
     IL_00c3:  ldloc.s    V_5
     IL_00c5:  ldloc.s    V_6
@@ -1227,18 +1193,18 @@
     IL_00d0:  ret
 
     IL_00d1:  ldarg.0
-    IL_00d2:  castclass  assembly/Test1/X14
+    IL_00d2:  castclass  Match01/Test1/X14
     IL_00d7:  stloc.s    V_11
     IL_00d9:  ldarg.1
-    IL_00da:  castclass  assembly/Test1/X14
+    IL_00da:  castclass  Match01/Test1/X14
     IL_00df:  stloc.s    V_12
     IL_00e1:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
     IL_00e6:  stloc.s    V_4
     IL_00e8:  ldloc.s    V_11
-    IL_00ea:  ldfld      int32 assembly/Test1/X14::item
+    IL_00ea:  ldfld      int32 Match01/Test1/X14::item
     IL_00ef:  stloc.s    V_5
     IL_00f1:  ldloc.s    V_12
-    IL_00f3:  ldfld      int32 assembly/Test1/X14::item
+    IL_00f3:  ldfld      int32 Match01/Test1/X14::item
     IL_00f8:  stloc.s    V_6
     IL_00fa:  ldloc.s    V_5
     IL_00fc:  ldloc.s    V_6
@@ -1255,9 +1221,9 @@
     IL_010b:  ret
   } 
 
-  .method assembly static int32  'CompareTo$cont@4-1'(class assembly/Test1 this,
+  .method assembly static int32  'CompareTo$cont@4-1'(class Match01/Test1 this,
                                                       object obj,
-                                                      class assembly/Test1 objTemp,
+                                                      class Match01/Test1 objTemp,
                                                       class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
   {
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -1265,48 +1231,48 @@
     .maxstack  5
     .locals init (int32 V_0,
              int32 V_1,
-             class assembly/Test1/X11 V_2,
-             class assembly/Test1/X11 V_3,
+             class Match01/Test1/X11 V_2,
+             class Match01/Test1/X11 V_3,
              int32 V_4,
              int32 V_5,
-             class assembly/Test1/X12 V_6,
-             class assembly/Test1/X12 V_7,
-             class assembly/Test1/X13 V_8,
-             class assembly/Test1/X13 V_9,
-             class assembly/Test1/X14 V_10,
-             class assembly/Test1/X14 V_11)
+             class Match01/Test1/X12 V_6,
+             class Match01/Test1/X12 V_7,
+             class Match01/Test1/X13 V_8,
+             class Match01/Test1/X13 V_9,
+             class Match01/Test1/X14 V_10,
+             class Match01/Test1/X14 V_11)
     IL_0000:  ldarg.1
-    IL_0001:  unbox.any  assembly/Test1
+    IL_0001:  unbox.any  Match01/Test1
     IL_0006:  brfalse    IL_00fb
 
     IL_000b:  ldarg.0
-    IL_000c:  ldfld      int32 assembly/Test1::_tag
+    IL_000c:  ldfld      int32 Match01/Test1::_tag
     IL_0011:  stloc.0
     IL_0012:  ldarg.2
-    IL_0013:  ldfld      int32 assembly/Test1::_tag
+    IL_0013:  ldfld      int32 Match01/Test1::_tag
     IL_0018:  stloc.1
     IL_0019:  ldloc.0
     IL_001a:  ldloc.1
     IL_001b:  bne.un     IL_00f7
 
     IL_0020:  ldarg.0
-    IL_0021:  call       instance int32 assembly/Test1::get_Tag()
+    IL_0021:  call       instance int32 Match01/Test1::get_Tag()
     IL_0026:  switch     ( 
                           IL_003b,
                           IL_0067,
                           IL_0097,
                           IL_00c7)
     IL_003b:  ldarg.0
-    IL_003c:  castclass  assembly/Test1/X11
+    IL_003c:  castclass  Match01/Test1/X11
     IL_0041:  stloc.2
     IL_0042:  ldarg.2
-    IL_0043:  castclass  assembly/Test1/X11
+    IL_0043:  castclass  Match01/Test1/X11
     IL_0048:  stloc.3
     IL_0049:  ldloc.2
-    IL_004a:  ldfld      int32 assembly/Test1/X11::item
+    IL_004a:  ldfld      int32 Match01/Test1/X11::item
     IL_004f:  stloc.s    V_4
     IL_0051:  ldloc.3
-    IL_0052:  ldfld      int32 assembly/Test1/X11::item
+    IL_0052:  ldfld      int32 Match01/Test1/X11::item
     IL_0057:  stloc.s    V_5
     IL_0059:  ldloc.s    V_4
     IL_005b:  ldloc.s    V_5
@@ -1318,16 +1284,16 @@
     IL_0066:  ret
 
     IL_0067:  ldarg.0
-    IL_0068:  castclass  assembly/Test1/X12
+    IL_0068:  castclass  Match01/Test1/X12
     IL_006d:  stloc.s    V_6
     IL_006f:  ldarg.2
-    IL_0070:  castclass  assembly/Test1/X12
+    IL_0070:  castclass  Match01/Test1/X12
     IL_0075:  stloc.s    V_7
     IL_0077:  ldloc.s    V_6
-    IL_0079:  ldfld      int32 assembly/Test1/X12::item
+    IL_0079:  ldfld      int32 Match01/Test1/X12::item
     IL_007e:  stloc.s    V_4
     IL_0080:  ldloc.s    V_7
-    IL_0082:  ldfld      int32 assembly/Test1/X12::item
+    IL_0082:  ldfld      int32 Match01/Test1/X12::item
     IL_0087:  stloc.s    V_5
     IL_0089:  ldloc.s    V_4
     IL_008b:  ldloc.s    V_5
@@ -1339,16 +1305,16 @@
     IL_0096:  ret
 
     IL_0097:  ldarg.0
-    IL_0098:  castclass  assembly/Test1/X13
+    IL_0098:  castclass  Match01/Test1/X13
     IL_009d:  stloc.s    V_8
     IL_009f:  ldarg.2
-    IL_00a0:  castclass  assembly/Test1/X13
+    IL_00a0:  castclass  Match01/Test1/X13
     IL_00a5:  stloc.s    V_9
     IL_00a7:  ldloc.s    V_8
-    IL_00a9:  ldfld      int32 assembly/Test1/X13::item
+    IL_00a9:  ldfld      int32 Match01/Test1/X13::item
     IL_00ae:  stloc.s    V_4
     IL_00b0:  ldloc.s    V_9
-    IL_00b2:  ldfld      int32 assembly/Test1/X13::item
+    IL_00b2:  ldfld      int32 Match01/Test1/X13::item
     IL_00b7:  stloc.s    V_5
     IL_00b9:  ldloc.s    V_4
     IL_00bb:  ldloc.s    V_5
@@ -1360,16 +1326,16 @@
     IL_00c6:  ret
 
     IL_00c7:  ldarg.0
-    IL_00c8:  castclass  assembly/Test1/X14
+    IL_00c8:  castclass  Match01/Test1/X14
     IL_00cd:  stloc.s    V_10
     IL_00cf:  ldarg.2
-    IL_00d0:  castclass  assembly/Test1/X14
+    IL_00d0:  castclass  Match01/Test1/X14
     IL_00d5:  stloc.s    V_11
     IL_00d7:  ldloc.s    V_10
-    IL_00d9:  ldfld      int32 assembly/Test1/X14::item
+    IL_00d9:  ldfld      int32 Match01/Test1/X14::item
     IL_00de:  stloc.s    V_4
     IL_00e0:  ldloc.s    V_11
-    IL_00e2:  ldfld      int32 assembly/Test1/X14::item
+    IL_00e2:  ldfld      int32 Match01/Test1/X14::item
     IL_00e7:  stloc.s    V_5
     IL_00e9:  ldloc.s    V_4
     IL_00eb:  ldloc.s    V_5
@@ -1389,21 +1355,21 @@
     IL_00fc:  ret
   } 
 
-  .method public static int32  select1(class assembly/Test1 x) cil managed
+  .method public static int32  select1(class Match01/Test1 x) cil managed
   {
     
     .maxstack  8
     IL_0000:  nop
     IL_0001:  ldarg.0
-    IL_0002:  call       instance int32 assembly/Test1::get_Tag()
+    IL_0002:  call       instance int32 Match01/Test1::get_Tag()
     IL_0007:  switch     ( 
                           IL_001c,
                           IL_0028,
                           IL_002a,
                           IL_002c)
     IL_001c:  ldarg.0
-    IL_001d:  castclass  assembly/Test1/X11
-    IL_0022:  ldfld      int32 assembly/Test1/X11::item
+    IL_001d:  castclass  Match01/Test1/X11
+    IL_0022:  ldfld      int32 Match01/Test1/X11::item
     IL_0027:  ret
 
     IL_0028:  ldc.i4.2
@@ -1416,18 +1382,18 @@
     IL_002d:  ret
   } 
 
-  .method public static int32  fm(class assembly/Test1 y) cil managed
+  .method public static int32  fm(class Match01/Test1 y) cil managed
   {
     
     .maxstack  8
     IL_0000:  ldarg.0
-    IL_0001:  call       int32 assembly::select1(class assembly/Test1)
+    IL_0001:  call       int32 Match01::select1(class Match01/Test1)
     IL_0006:  ret
   } 
 
 } 
 
-.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Match01
        extends [runtime]System.Object
 {
   .method public static void  main@() cil managed
@@ -1494,8 +1460,7 @@
     IL_0014:  ret
   } 
 
-  .method public hidebysig specialname instance class [runtime]System.Type 
-          get_Type() cil managed
+  .method public hidebysig specialname instance class [runtime]System.Type get_Type() cil managed
   {
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -1506,8 +1471,7 @@
     IL_0006:  ret
   } 
 
-  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes 
-          get_MemberType() cil managed
+  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes get_MemberType() cil managed
   {
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOff.fs.il.netcore.debug.bsl
similarity index 76%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOff.fs.il.netcore.debug.bsl
index a26af5e534a..c40defd36ee 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01.fs.il.netcore.debug.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOff.fs.il.netcore.debug.bsl
@@ -39,15 +39,15 @@
 
 
 
-.class public abstract auto ansi sealed assembly
+.class public abstract auto ansi sealed Match01
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
   .class abstract auto autochar serializable nested public beforefieldinit Test1
          extends [runtime]System.Object
-         implements class [runtime]System.IEquatable`1<class assembly/Test1>,
+         implements class [runtime]System.IEquatable`1<class Match01/Test1>,
                     [runtime]System.Collections.IStructuralEquatable,
-                    class [runtime]System.IComparable`1<class assembly/Test1>,
+                    class [runtime]System.IComparable`1<class Match01/Test1>,
                     [runtime]System.IComparable,
                     [runtime]System.Collections.IStructuralComparable
   {
@@ -64,7 +64,7 @@
     } 
 
     .class auto ansi serializable nested public beforefieldinit specialname X11
-           extends assembly/Test1
+           extends Match01/Test1
     {
       .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
                                                                                                                                         2B 58 31 31 40 44 65 62 75 67 54 79 70 65 50 72   
@@ -75,8 +75,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(int32 item) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
       {
         .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -87,22 +86,21 @@
         .maxstack  8
         IL_0000:  ldarg.0
         IL_0001:  ldc.i4.0
-        IL_0002:  call       instance void assembly/Test1::.ctor(int32)
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
         IL_0007:  ldarg.0
         IL_0008:  ldarg.1
-        IL_0009:  stfld      int32 assembly/Test1/X11::item
+        IL_0009:  stfld      int32 Match01/Test1/X11::item
         IL_000e:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      int32 assembly/Test1/X11::item
+        IL_0001:  ldfld      int32 Match01/Test1/X11::item
         IL_0006:  ret
       } 
 
@@ -113,12 +111,12 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X11::get_Item()
+        .get instance int32 Match01/Test1/X11::get_Item()
       } 
     } 
 
     .class auto ansi serializable nested public beforefieldinit specialname X12
-           extends assembly/Test1
+           extends Match01/Test1
     {
       .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
                                                                                                                                         2B 58 31 32 40 44 65 62 75 67 54 79 70 65 50 72   
@@ -129,8 +127,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(int32 item) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
       {
         .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -141,22 +138,21 @@
         .maxstack  8
         IL_0000:  ldarg.0
         IL_0001:  ldc.i4.1
-        IL_0002:  call       instance void assembly/Test1::.ctor(int32)
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
         IL_0007:  ldarg.0
         IL_0008:  ldarg.1
-        IL_0009:  stfld      int32 assembly/Test1/X12::item
+        IL_0009:  stfld      int32 Match01/Test1/X12::item
         IL_000e:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      int32 assembly/Test1/X12::item
+        IL_0001:  ldfld      int32 Match01/Test1/X12::item
         IL_0006:  ret
       } 
 
@@ -167,12 +163,12 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 01 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X12::get_Item()
+        .get instance int32 Match01/Test1/X12::get_Item()
       } 
     } 
 
     .class auto ansi serializable nested public beforefieldinit specialname X13
-           extends assembly/Test1
+           extends Match01/Test1
     {
       .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
                                                                                                                                         2B 58 31 33 40 44 65 62 75 67 54 79 70 65 50 72   
@@ -183,8 +179,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(int32 item) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
       {
         .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -195,22 +190,21 @@
         .maxstack  8
         IL_0000:  ldarg.0
         IL_0001:  ldc.i4.2
-        IL_0002:  call       instance void assembly/Test1::.ctor(int32)
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
         IL_0007:  ldarg.0
         IL_0008:  ldarg.1
-        IL_0009:  stfld      int32 assembly/Test1/X13::item
+        IL_0009:  stfld      int32 Match01/Test1/X13::item
         IL_000e:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      int32 assembly/Test1/X13::item
+        IL_0001:  ldfld      int32 Match01/Test1/X13::item
         IL_0006:  ret
       } 
 
@@ -221,12 +215,12 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 02 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X13::get_Item()
+        .get instance int32 Match01/Test1/X13::get_Item()
       } 
     } 
 
     .class auto ansi serializable nested public beforefieldinit specialname X14
-           extends assembly/Test1
+           extends Match01/Test1
     {
       .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
                                                                                                                                         2B 58 31 34 40 44 65 62 75 67 54 79 70 65 50 72   
@@ -237,8 +231,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(int32 item) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
       {
         .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -249,22 +242,21 @@
         .maxstack  8
         IL_0000:  ldarg.0
         IL_0001:  ldc.i4.3
-        IL_0002:  call       instance void assembly/Test1::.ctor(int32)
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
         IL_0007:  ldarg.0
         IL_0008:  ldarg.1
-        IL_0009:  stfld      int32 assembly/Test1/X14::item
+        IL_0009:  stfld      int32 Match01/Test1/X14::item
         IL_000e:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      int32 assembly/Test1/X14::item
+        IL_0001:  ldfld      int32 Match01/Test1/X14::item
         IL_0006:  ret
       } 
 
@@ -275,19 +267,18 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 03 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X14::get_Item()
+        .get instance int32 Match01/Test1/X14::get_Item()
       } 
     } 
 
     .class auto ansi nested assembly beforefieldinit specialname X11@DebugTypeProxy
            extends [runtime]System.Object
     {
-      .field assembly class assembly/Test1/X11 _obj
+      .field assembly class Match01/Test1/X11 _obj
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method public specialname rtspecialname 
-              instance void  .ctor(class assembly/Test1/X11 obj) cil managed
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X11 obj) cil managed
       {
         .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -300,20 +291,19 @@
         IL_0001:  call       instance void [runtime]System.Object::.ctor()
         IL_0006:  ldarg.0
         IL_0007:  ldarg.1
-        IL_0008:  stfld      class assembly/Test1/X11 assembly/Test1/X11@DebugTypeProxy::_obj
+        IL_0008:  stfld      class Match01/Test1/X11 Match01/Test1/X11@DebugTypeProxy::_obj
         IL_000d:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      class assembly/Test1/X11 assembly/Test1/X11@DebugTypeProxy::_obj
-        IL_0006:  ldfld      int32 assembly/Test1/X11::item
+        IL_0001:  ldfld      class Match01/Test1/X11 Match01/Test1/X11@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X11::item
         IL_000b:  ret
       } 
 
@@ -324,19 +314,18 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X11@DebugTypeProxy::get_Item()
+        .get instance int32 Match01/Test1/X11@DebugTypeProxy::get_Item()
       } 
     } 
 
     .class auto ansi nested assembly beforefieldinit specialname X12@DebugTypeProxy
            extends [runtime]System.Object
     {
-      .field assembly class assembly/Test1/X12 _obj
+      .field assembly class Match01/Test1/X12 _obj
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method public specialname rtspecialname 
-              instance void  .ctor(class assembly/Test1/X12 obj) cil managed
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X12 obj) cil managed
       {
         .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -349,20 +338,19 @@
         IL_0001:  call       instance void [runtime]System.Object::.ctor()
         IL_0006:  ldarg.0
         IL_0007:  ldarg.1
-        IL_0008:  stfld      class assembly/Test1/X12 assembly/Test1/X12@DebugTypeProxy::_obj
+        IL_0008:  stfld      class Match01/Test1/X12 Match01/Test1/X12@DebugTypeProxy::_obj
         IL_000d:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      class assembly/Test1/X12 assembly/Test1/X12@DebugTypeProxy::_obj
-        IL_0006:  ldfld      int32 assembly/Test1/X12::item
+        IL_0001:  ldfld      class Match01/Test1/X12 Match01/Test1/X12@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X12::item
         IL_000b:  ret
       } 
 
@@ -373,19 +361,18 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 01 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X12@DebugTypeProxy::get_Item()
+        .get instance int32 Match01/Test1/X12@DebugTypeProxy::get_Item()
       } 
     } 
 
     .class auto ansi nested assembly beforefieldinit specialname X13@DebugTypeProxy
            extends [runtime]System.Object
     {
-      .field assembly class assembly/Test1/X13 _obj
+      .field assembly class Match01/Test1/X13 _obj
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method public specialname rtspecialname 
-              instance void  .ctor(class assembly/Test1/X13 obj) cil managed
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X13 obj) cil managed
       {
         .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -398,20 +385,19 @@
         IL_0001:  call       instance void [runtime]System.Object::.ctor()
         IL_0006:  ldarg.0
         IL_0007:  ldarg.1
-        IL_0008:  stfld      class assembly/Test1/X13 assembly/Test1/X13@DebugTypeProxy::_obj
+        IL_0008:  stfld      class Match01/Test1/X13 Match01/Test1/X13@DebugTypeProxy::_obj
         IL_000d:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      class assembly/Test1/X13 assembly/Test1/X13@DebugTypeProxy::_obj
-        IL_0006:  ldfld      int32 assembly/Test1/X13::item
+        IL_0001:  ldfld      class Match01/Test1/X13 Match01/Test1/X13@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X13::item
         IL_000b:  ret
       } 
 
@@ -422,19 +408,18 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 02 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X13@DebugTypeProxy::get_Item()
+        .get instance int32 Match01/Test1/X13@DebugTypeProxy::get_Item()
       } 
     } 
 
     .class auto ansi nested assembly beforefieldinit specialname X14@DebugTypeProxy
            extends [runtime]System.Object
     {
-      .field assembly class assembly/Test1/X14 _obj
+      .field assembly class Match01/Test1/X14 _obj
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method public specialname rtspecialname 
-              instance void  .ctor(class assembly/Test1/X14 obj) cil managed
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X14 obj) cil managed
       {
         .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -447,20 +432,19 @@
         IL_0001:  call       instance void [runtime]System.Object::.ctor()
         IL_0006:  ldarg.0
         IL_0007:  ldarg.1
-        IL_0008:  stfld      class assembly/Test1/X14 assembly/Test1/X14@DebugTypeProxy::_obj
+        IL_0008:  stfld      class Match01/Test1/X14 Match01/Test1/X14@DebugTypeProxy::_obj
         IL_000d:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      class assembly/Test1/X14 assembly/Test1/X14@DebugTypeProxy::_obj
-        IL_0006:  ldfld      int32 assembly/Test1/X14::item
+        IL_0001:  ldfld      class Match01/Test1/X14 Match01/Test1/X14@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X14::item
         IL_000b:  ret
       } 
 
@@ -471,7 +455,7 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 03 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X14@DebugTypeProxy::get_Item()
+        .get instance int32 Match01/Test1/X14@DebugTypeProxy::get_Item()
       } 
     } 
 
@@ -479,8 +463,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(int32 _tag) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(int32 _tag) cil managed
     {
       .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                               class [runtime]System.Type) = ( 01 00 E0 07 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -493,157 +476,145 @@
       IL_0001:  call       instance void [runtime]System.Object::.ctor()
       IL_0006:  ldarg.0
       IL_0007:  ldarg.1
-      IL_0008:  stfld      int32 assembly/Test1::_tag
+      IL_0008:  stfld      int32 Match01/Test1::_tag
       IL_000d:  ret
     } 
 
-    .method public static class assembly/Test1 
-            NewX11(int32 item) cil managed
+    .method public static class Match01/Test1 NewX11(int32 item) cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  newobj     instance void assembly/Test1/X11::.ctor(int32)
+      IL_0001:  newobj     instance void Match01/Test1/X11::.ctor(int32)
       IL_0006:  ret
     } 
 
-    .method public hidebysig instance bool 
-            get_IsX11() cil managed
+    .method public hidebysig instance bool get_IsX11() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
       IL_0006:  ldc.i4.0
       IL_0007:  ceq
       IL_0009:  ret
     } 
 
-    .method public static class assembly/Test1 
-            NewX12(int32 item) cil managed
+    .method public static class Match01/Test1 NewX12(int32 item) cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 01 00 00 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  newobj     instance void assembly/Test1/X12::.ctor(int32)
+      IL_0001:  newobj     instance void Match01/Test1/X12::.ctor(int32)
       IL_0006:  ret
     } 
 
-    .method public hidebysig instance bool 
-            get_IsX12() cil managed
+    .method public hidebysig instance bool get_IsX12() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
       IL_0006:  ldc.i4.1
       IL_0007:  ceq
       IL_0009:  ret
     } 
 
-    .method public static class assembly/Test1 
-            NewX13(int32 item) cil managed
+    .method public static class Match01/Test1 NewX13(int32 item) cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 02 00 00 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  newobj     instance void assembly/Test1/X13::.ctor(int32)
+      IL_0001:  newobj     instance void Match01/Test1/X13::.ctor(int32)
       IL_0006:  ret
     } 
 
-    .method public hidebysig instance bool 
-            get_IsX13() cil managed
+    .method public hidebysig instance bool get_IsX13() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
       IL_0006:  ldc.i4.2
       IL_0007:  ceq
       IL_0009:  ret
     } 
 
-    .method public static class assembly/Test1 
-            NewX14(int32 item) cil managed
+    .method public static class Match01/Test1 NewX14(int32 item) cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 03 00 00 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  newobj     instance void assembly/Test1/X14::.ctor(int32)
+      IL_0001:  newobj     instance void Match01/Test1/X14::.ctor(int32)
       IL_0006:  ret
     } 
 
-    .method public hidebysig instance bool 
-            get_IsX14() cil managed
+    .method public hidebysig instance bool get_IsX14() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
       IL_0006:  ldc.i4.3
       IL_0007:  ceq
       IL_0009:  ret
     } 
 
-    .method public hidebysig instance int32 
-            get_Tag() cil managed
+    .method public hidebysig instance int32 get_Tag() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  ldfld      int32 assembly/Test1::_tag
+      IL_0001:  ldfld      int32 Match01/Test1::_tag
       IL_0006:  ret
     } 
 
-    .method assembly hidebysig specialname 
-            instance object  __DebugDisplay() cil managed
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldstr      "%+0.8A"
-      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
-      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
       IL_000f:  ldarg.0
-      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>::Invoke(!0)
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>::Invoke(!0)
       IL_0015:  ret
     } 
 
-    .method public strict virtual instance string 
-            ToString() cil managed
+    .method public strict virtual instance string ToString() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldstr      "%+A"
-      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class assembly/Test1>::.ctor(string)
-      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class Match01/Test1>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
       IL_000f:  ldarg.0
-      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>::Invoke(!0)
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>::Invoke(!0)
       IL_0015:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(class assembly/Test1 obj) cil managed
+    .method public hidebysig virtual final instance int32  CompareTo(class Match01/Test1 obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -657,8 +628,8 @@
       IL_0006:  ldarg.0
       IL_0007:  ldarg.1
       IL_0008:  ldnull
-      IL_0009:  call       int32 assembly::CompareTo$cont@4(class assembly/Test1,
-                                                           class assembly/Test1,
+      IL_0009:  call       int32 Match01::CompareTo$cont@4(class Match01/Test1,
+                                                           class Match01/Test1,
                                                            class [FSharp.Core]Microsoft.FSharp.Core.Unit)
       IL_000e:  ret
 
@@ -675,16 +646,15 @@
       IL_0017:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(object obj) cil managed
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
       IL_0001:  ldarg.1
-      IL_0002:  unbox.any  assembly/Test1
-      IL_0007:  callvirt   instance int32 assembly/Test1::CompareTo(class assembly/Test1)
+      IL_0002:  unbox.any  Match01/Test1
+      IL_0007:  callvirt   instance int32 Match01/Test1::CompareTo(class Match01/Test1)
       IL_000c:  ret
     } 
 
@@ -695,22 +665,22 @@
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  5
-      .locals init (class assembly/Test1 V_0)
+      .locals init (class Match01/Test1 V_0)
       IL_0000:  ldarg.1
-      IL_0001:  unbox.any  assembly/Test1
+      IL_0001:  unbox.any  Match01/Test1
       IL_0006:  stloc.0
       IL_0007:  ldarg.0
       IL_0008:  brfalse.s  IL_001d
 
       IL_000a:  ldarg.1
-      IL_000b:  unbox.any  assembly/Test1
+      IL_000b:  unbox.any  Match01/Test1
       IL_0010:  brfalse.s  IL_001b
 
       IL_0012:  ldarg.0
       IL_0013:  ldloc.0
       IL_0014:  ldnull
-      IL_0015:  call       int32 assembly::'CompareTo$cont@4-1'(class assembly/Test1,
-                                                               class assembly/Test1,
+      IL_0015:  call       int32 Match01::'CompareTo$cont@4-1'(class Match01/Test1,
+                                                               class Match01/Test1,
                                                                class [FSharp.Core]Microsoft.FSharp.Core.Unit)
       IL_001a:  ret
 
@@ -718,7 +688,7 @@
       IL_001c:  ret
 
       IL_001d:  ldarg.1
-      IL_001e:  unbox.any  assembly/Test1
+      IL_001e:  unbox.any  Match01/Test1
       IL_0023:  brfalse.s  IL_0027
 
       IL_0025:  ldc.i4.m1
@@ -728,37 +698,36 @@
       IL_0028:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  7
       .locals init (int32 V_0,
-               class assembly/Test1/X11 V_1,
-               class assembly/Test1/X12 V_2,
-               class assembly/Test1/X13 V_3,
-               class assembly/Test1/X14 V_4)
+               class Match01/Test1/X11 V_1,
+               class Match01/Test1/X12 V_2,
+               class Match01/Test1/X13 V_3,
+               class Match01/Test1/X14 V_4)
       IL_0000:  ldarg.0
       IL_0001:  brfalse    IL_00a5
 
       IL_0006:  ldc.i4.0
       IL_0007:  stloc.0
       IL_0008:  ldarg.0
-      IL_0009:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0009:  call       instance int32 Match01/Test1::get_Tag()
       IL_000e:  switch     ( 
                             IL_0023,
                             IL_0043,
                             IL_0063,
                             IL_0083)
       IL_0023:  ldarg.0
-      IL_0024:  castclass  assembly/Test1/X11
+      IL_0024:  castclass  Match01/Test1/X11
       IL_0029:  stloc.1
       IL_002a:  ldc.i4.0
       IL_002b:  stloc.0
       IL_002c:  ldc.i4     0x9e3779b9
       IL_0031:  ldloc.1
-      IL_0032:  ldfld      int32 assembly/Test1/X11::item
+      IL_0032:  ldfld      int32 Match01/Test1/X11::item
       IL_0037:  ldloc.0
       IL_0038:  ldc.i4.6
       IL_0039:  shl
@@ -773,13 +742,13 @@
       IL_0042:  ret
 
       IL_0043:  ldarg.0
-      IL_0044:  castclass  assembly/Test1/X12
+      IL_0044:  castclass  Match01/Test1/X12
       IL_0049:  stloc.2
       IL_004a:  ldc.i4.1
       IL_004b:  stloc.0
       IL_004c:  ldc.i4     0x9e3779b9
       IL_0051:  ldloc.2
-      IL_0052:  ldfld      int32 assembly/Test1/X12::item
+      IL_0052:  ldfld      int32 Match01/Test1/X12::item
       IL_0057:  ldloc.0
       IL_0058:  ldc.i4.6
       IL_0059:  shl
@@ -794,13 +763,13 @@
       IL_0062:  ret
 
       IL_0063:  ldarg.0
-      IL_0064:  castclass  assembly/Test1/X13
+      IL_0064:  castclass  Match01/Test1/X13
       IL_0069:  stloc.3
       IL_006a:  ldc.i4.2
       IL_006b:  stloc.0
       IL_006c:  ldc.i4     0x9e3779b9
       IL_0071:  ldloc.3
-      IL_0072:  ldfld      int32 assembly/Test1/X13::item
+      IL_0072:  ldfld      int32 Match01/Test1/X13::item
       IL_0077:  ldloc.0
       IL_0078:  ldc.i4.6
       IL_0079:  shl
@@ -815,13 +784,13 @@
       IL_0082:  ret
 
       IL_0083:  ldarg.0
-      IL_0084:  castclass  assembly/Test1/X14
+      IL_0084:  castclass  Match01/Test1/X14
       IL_0089:  stloc.s    V_4
       IL_008b:  ldc.i4.3
       IL_008c:  stloc.0
       IL_008d:  ldc.i4     0x9e3779b9
       IL_0092:  ldloc.s    V_4
-      IL_0094:  ldfld      int32 assembly/Test1/X14::item
+      IL_0094:  ldfld      int32 Match01/Test1/X14::item
       IL_0099:  ldloc.0
       IL_009a:  ldc.i4.6
       IL_009b:  shl
@@ -839,15 +808,14 @@
       IL_00a6:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode() cil managed
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
       IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
-      IL_0006:  callvirt   instance int32 assembly/Test1::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_0006:  callvirt   instance int32 Match01/Test1::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
       IL_000b:  ret
     } 
 
@@ -858,92 +826,92 @@
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  4
-      .locals init (class assembly/Test1 V_0,
+      .locals init (class Match01/Test1 V_0,
                int32 V_1,
                int32 V_2,
-               class assembly/Test1/X11 V_3,
-               class assembly/Test1/X11 V_4,
-               class assembly/Test1/X12 V_5,
-               class assembly/Test1/X12 V_6,
-               class assembly/Test1/X13 V_7,
-               class assembly/Test1/X13 V_8,
-               class assembly/Test1/X14 V_9,
-               class assembly/Test1/X14 V_10)
+               class Match01/Test1/X11 V_3,
+               class Match01/Test1/X11 V_4,
+               class Match01/Test1/X12 V_5,
+               class Match01/Test1/X12 V_6,
+               class Match01/Test1/X13 V_7,
+               class Match01/Test1/X13 V_8,
+               class Match01/Test1/X14 V_9,
+               class Match01/Test1/X14 V_10)
       IL_0000:  ldarg.0
       IL_0001:  brfalse    IL_00c9
 
       IL_0006:  ldarg.1
-      IL_0007:  isinst     assembly/Test1
+      IL_0007:  isinst     Match01/Test1
       IL_000c:  stloc.0
       IL_000d:  ldloc.0
       IL_000e:  brfalse    IL_00c7
 
       IL_0013:  ldarg.0
-      IL_0014:  ldfld      int32 assembly/Test1::_tag
+      IL_0014:  ldfld      int32 Match01/Test1::_tag
       IL_0019:  stloc.1
       IL_001a:  ldloc.0
-      IL_001b:  ldfld      int32 assembly/Test1::_tag
+      IL_001b:  ldfld      int32 Match01/Test1::_tag
       IL_0020:  stloc.2
       IL_0021:  ldloc.1
       IL_0022:  ldloc.2
       IL_0023:  bne.un     IL_00c5
 
       IL_0028:  ldarg.0
-      IL_0029:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0029:  call       instance int32 Match01/Test1::get_Tag()
       IL_002e:  switch     ( 
                             IL_0043,
                             IL_0062,
                             IL_0083,
                             IL_00a4)
       IL_0043:  ldarg.0
-      IL_0044:  castclass  assembly/Test1/X11
+      IL_0044:  castclass  Match01/Test1/X11
       IL_0049:  stloc.3
       IL_004a:  ldloc.0
-      IL_004b:  castclass  assembly/Test1/X11
+      IL_004b:  castclass  Match01/Test1/X11
       IL_0050:  stloc.s    V_4
       IL_0052:  ldloc.3
-      IL_0053:  ldfld      int32 assembly/Test1/X11::item
+      IL_0053:  ldfld      int32 Match01/Test1/X11::item
       IL_0058:  ldloc.s    V_4
-      IL_005a:  ldfld      int32 assembly/Test1/X11::item
+      IL_005a:  ldfld      int32 Match01/Test1/X11::item
       IL_005f:  ceq
       IL_0061:  ret
 
       IL_0062:  ldarg.0
-      IL_0063:  castclass  assembly/Test1/X12
+      IL_0063:  castclass  Match01/Test1/X12
       IL_0068:  stloc.s    V_5
       IL_006a:  ldloc.0
-      IL_006b:  castclass  assembly/Test1/X12
+      IL_006b:  castclass  Match01/Test1/X12
       IL_0070:  stloc.s    V_6
       IL_0072:  ldloc.s    V_5
-      IL_0074:  ldfld      int32 assembly/Test1/X12::item
+      IL_0074:  ldfld      int32 Match01/Test1/X12::item
       IL_0079:  ldloc.s    V_6
-      IL_007b:  ldfld      int32 assembly/Test1/X12::item
+      IL_007b:  ldfld      int32 Match01/Test1/X12::item
       IL_0080:  ceq
       IL_0082:  ret
 
       IL_0083:  ldarg.0
-      IL_0084:  castclass  assembly/Test1/X13
+      IL_0084:  castclass  Match01/Test1/X13
       IL_0089:  stloc.s    V_7
       IL_008b:  ldloc.0
-      IL_008c:  castclass  assembly/Test1/X13
+      IL_008c:  castclass  Match01/Test1/X13
       IL_0091:  stloc.s    V_8
       IL_0093:  ldloc.s    V_7
-      IL_0095:  ldfld      int32 assembly/Test1/X13::item
+      IL_0095:  ldfld      int32 Match01/Test1/X13::item
       IL_009a:  ldloc.s    V_8
-      IL_009c:  ldfld      int32 assembly/Test1/X13::item
+      IL_009c:  ldfld      int32 Match01/Test1/X13::item
       IL_00a1:  ceq
       IL_00a3:  ret
 
       IL_00a4:  ldarg.0
-      IL_00a5:  castclass  assembly/Test1/X14
+      IL_00a5:  castclass  Match01/Test1/X14
       IL_00aa:  stloc.s    V_9
       IL_00ac:  ldloc.0
-      IL_00ad:  castclass  assembly/Test1/X14
+      IL_00ad:  castclass  Match01/Test1/X14
       IL_00b2:  stloc.s    V_10
       IL_00b4:  ldloc.s    V_9
-      IL_00b6:  ldfld      int32 assembly/Test1/X14::item
+      IL_00b6:  ldfld      int32 Match01/Test1/X14::item
       IL_00bb:  ldloc.s    V_10
-      IL_00bd:  ldfld      int32 assembly/Test1/X14::item
+      IL_00bd:  ldfld      int32 Match01/Test1/X14::item
       IL_00c2:  ceq
       IL_00c4:  ret
 
@@ -961,22 +929,21 @@
       IL_00d0:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance bool  Equals(class assembly/Test1 obj) cil managed
+    .method public hidebysig virtual final instance bool  Equals(class Match01/Test1 obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  4
       .locals init (int32 V_0,
                int32 V_1,
-               class assembly/Test1/X11 V_2,
-               class assembly/Test1/X11 V_3,
-               class assembly/Test1/X12 V_4,
-               class assembly/Test1/X12 V_5,
-               class assembly/Test1/X13 V_6,
-               class assembly/Test1/X13 V_7,
-               class assembly/Test1/X14 V_8,
-               class assembly/Test1/X14 V_9)
+               class Match01/Test1/X11 V_2,
+               class Match01/Test1/X11 V_3,
+               class Match01/Test1/X12 V_4,
+               class Match01/Test1/X12 V_5,
+               class Match01/Test1/X13 V_6,
+               class Match01/Test1/X13 V_7,
+               class Match01/Test1/X14 V_8,
+               class Match01/Test1/X14 V_9)
       IL_0000:  ldarg.0
       IL_0001:  brfalse    IL_00c0
 
@@ -984,71 +951,71 @@
       IL_0007:  brfalse    IL_00be
 
       IL_000c:  ldarg.0
-      IL_000d:  ldfld      int32 assembly/Test1::_tag
+      IL_000d:  ldfld      int32 Match01/Test1::_tag
       IL_0012:  stloc.0
       IL_0013:  ldarg.1
-      IL_0014:  ldfld      int32 assembly/Test1::_tag
+      IL_0014:  ldfld      int32 Match01/Test1::_tag
       IL_0019:  stloc.1
       IL_001a:  ldloc.0
       IL_001b:  ldloc.1
       IL_001c:  bne.un     IL_00bc
 
       IL_0021:  ldarg.0
-      IL_0022:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0022:  call       instance int32 Match01/Test1::get_Tag()
       IL_0027:  switch     ( 
                             IL_003c,
                             IL_0059,
                             IL_007a,
                             IL_009b)
       IL_003c:  ldarg.0
-      IL_003d:  castclass  assembly/Test1/X11
+      IL_003d:  castclass  Match01/Test1/X11
       IL_0042:  stloc.2
       IL_0043:  ldarg.1
-      IL_0044:  castclass  assembly/Test1/X11
+      IL_0044:  castclass  Match01/Test1/X11
       IL_0049:  stloc.3
       IL_004a:  ldloc.2
-      IL_004b:  ldfld      int32 assembly/Test1/X11::item
+      IL_004b:  ldfld      int32 Match01/Test1/X11::item
       IL_0050:  ldloc.3
-      IL_0051:  ldfld      int32 assembly/Test1/X11::item
+      IL_0051:  ldfld      int32 Match01/Test1/X11::item
       IL_0056:  ceq
       IL_0058:  ret
 
       IL_0059:  ldarg.0
-      IL_005a:  castclass  assembly/Test1/X12
+      IL_005a:  castclass  Match01/Test1/X12
       IL_005f:  stloc.s    V_4
       IL_0061:  ldarg.1
-      IL_0062:  castclass  assembly/Test1/X12
+      IL_0062:  castclass  Match01/Test1/X12
       IL_0067:  stloc.s    V_5
       IL_0069:  ldloc.s    V_4
-      IL_006b:  ldfld      int32 assembly/Test1/X12::item
+      IL_006b:  ldfld      int32 Match01/Test1/X12::item
       IL_0070:  ldloc.s    V_5
-      IL_0072:  ldfld      int32 assembly/Test1/X12::item
+      IL_0072:  ldfld      int32 Match01/Test1/X12::item
       IL_0077:  ceq
       IL_0079:  ret
 
       IL_007a:  ldarg.0
-      IL_007b:  castclass  assembly/Test1/X13
+      IL_007b:  castclass  Match01/Test1/X13
       IL_0080:  stloc.s    V_6
       IL_0082:  ldarg.1
-      IL_0083:  castclass  assembly/Test1/X13
+      IL_0083:  castclass  Match01/Test1/X13
       IL_0088:  stloc.s    V_7
       IL_008a:  ldloc.s    V_6
-      IL_008c:  ldfld      int32 assembly/Test1/X13::item
+      IL_008c:  ldfld      int32 Match01/Test1/X13::item
       IL_0091:  ldloc.s    V_7
-      IL_0093:  ldfld      int32 assembly/Test1/X13::item
+      IL_0093:  ldfld      int32 Match01/Test1/X13::item
       IL_0098:  ceq
       IL_009a:  ret
 
       IL_009b:  ldarg.0
-      IL_009c:  castclass  assembly/Test1/X14
+      IL_009c:  castclass  Match01/Test1/X14
       IL_00a1:  stloc.s    V_8
       IL_00a3:  ldarg.1
-      IL_00a4:  castclass  assembly/Test1/X14
+      IL_00a4:  castclass  Match01/Test1/X14
       IL_00a9:  stloc.s    V_9
       IL_00ab:  ldloc.s    V_8
-      IL_00ad:  ldfld      int32 assembly/Test1/X14::item
+      IL_00ad:  ldfld      int32 Match01/Test1/X14::item
       IL_00b2:  ldloc.s    V_9
-      IL_00b4:  ldfld      int32 assembly/Test1/X14::item
+      IL_00b4:  ldfld      int32 Match01/Test1/X14::item
       IL_00b9:  ceq
       IL_00bb:  ret
 
@@ -1066,22 +1033,21 @@
       IL_00c7:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance bool  Equals(object obj) cil managed
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  4
-      .locals init (class assembly/Test1 V_0)
+      .locals init (class Match01/Test1 V_0)
       IL_0000:  ldarg.1
-      IL_0001:  isinst     assembly/Test1
+      IL_0001:  isinst     Match01/Test1
       IL_0006:  stloc.0
       IL_0007:  ldloc.0
       IL_0008:  brfalse.s  IL_0012
 
       IL_000a:  ldarg.0
       IL_000b:  ldloc.0
-      IL_000c:  callvirt   instance bool assembly/Test1::Equals(class assembly/Test1)
+      IL_000c:  callvirt   instance bool Match01/Test1::Equals(class Match01/Test1)
       IL_0011:  ret
 
       IL_0012:  ldc.i4.0
@@ -1093,40 +1059,40 @@
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance int32 assembly/Test1::get_Tag()
+      .get instance int32 Match01/Test1::get_Tag()
     } 
     .property instance bool IsX11()
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance bool assembly/Test1::get_IsX11()
+      .get instance bool Match01/Test1::get_IsX11()
     } 
     .property instance bool IsX12()
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance bool assembly/Test1::get_IsX12()
+      .get instance bool Match01/Test1::get_IsX12()
     } 
     .property instance bool IsX13()
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance bool assembly/Test1::get_IsX13()
+      .get instance bool Match01/Test1::get_IsX13()
     } 
     .property instance bool IsX14()
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance bool assembly/Test1::get_IsX14()
+      .get instance bool Match01/Test1::get_IsX14()
     } 
   } 
 
-  .method assembly static int32  CompareTo$cont@4(class assembly/Test1 this,
-                                                  class assembly/Test1 obj,
+  .method assembly static int32  CompareTo$cont@4(class Match01/Test1 this,
+                                                  class Match01/Test1 obj,
                                                   class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
   {
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -1134,47 +1100,47 @@
     .maxstack  5
     .locals init (int32 V_0,
              int32 V_1,
-             class assembly/Test1/X11 V_2,
-             class assembly/Test1/X11 V_3,
+             class Match01/Test1/X11 V_2,
+             class Match01/Test1/X11 V_3,
              class [runtime]System.Collections.IComparer V_4,
              int32 V_5,
              int32 V_6,
-             class assembly/Test1/X12 V_7,
-             class assembly/Test1/X12 V_8,
-             class assembly/Test1/X13 V_9,
-             class assembly/Test1/X13 V_10,
-             class assembly/Test1/X14 V_11,
-             class assembly/Test1/X14 V_12)
+             class Match01/Test1/X12 V_7,
+             class Match01/Test1/X12 V_8,
+             class Match01/Test1/X13 V_9,
+             class Match01/Test1/X13 V_10,
+             class Match01/Test1/X14 V_11,
+             class Match01/Test1/X14 V_12)
     IL_0000:  ldarg.0
-    IL_0001:  ldfld      int32 assembly/Test1::_tag
+    IL_0001:  ldfld      int32 Match01/Test1::_tag
     IL_0006:  stloc.0
     IL_0007:  ldarg.1
-    IL_0008:  ldfld      int32 assembly/Test1::_tag
+    IL_0008:  ldfld      int32 Match01/Test1::_tag
     IL_000d:  stloc.1
     IL_000e:  ldloc.0
     IL_000f:  ldloc.1
     IL_0010:  bne.un     IL_0108
 
     IL_0015:  ldarg.0
-    IL_0016:  call       instance int32 assembly/Test1::get_Tag()
+    IL_0016:  call       instance int32 Match01/Test1::get_Tag()
     IL_001b:  switch     ( 
                           IL_0030,
                           IL_0063,
                           IL_009a,
                           IL_00d1)
     IL_0030:  ldarg.0
-    IL_0031:  castclass  assembly/Test1/X11
+    IL_0031:  castclass  Match01/Test1/X11
     IL_0036:  stloc.2
     IL_0037:  ldarg.1
-    IL_0038:  castclass  assembly/Test1/X11
+    IL_0038:  castclass  Match01/Test1/X11
     IL_003d:  stloc.3
     IL_003e:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
     IL_0043:  stloc.s    V_4
     IL_0045:  ldloc.2
-    IL_0046:  ldfld      int32 assembly/Test1/X11::item
+    IL_0046:  ldfld      int32 Match01/Test1/X11::item
     IL_004b:  stloc.s    V_5
     IL_004d:  ldloc.3
-    IL_004e:  ldfld      int32 assembly/Test1/X11::item
+    IL_004e:  ldfld      int32 Match01/Test1/X11::item
     IL_0053:  stloc.s    V_6
     IL_0055:  ldloc.s    V_5
     IL_0057:  ldloc.s    V_6
@@ -1186,18 +1152,18 @@
     IL_0062:  ret
 
     IL_0063:  ldarg.0
-    IL_0064:  castclass  assembly/Test1/X12
+    IL_0064:  castclass  Match01/Test1/X12
     IL_0069:  stloc.s    V_7
     IL_006b:  ldarg.1
-    IL_006c:  castclass  assembly/Test1/X12
+    IL_006c:  castclass  Match01/Test1/X12
     IL_0071:  stloc.s    V_8
     IL_0073:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
     IL_0078:  stloc.s    V_4
     IL_007a:  ldloc.s    V_7
-    IL_007c:  ldfld      int32 assembly/Test1/X12::item
+    IL_007c:  ldfld      int32 Match01/Test1/X12::item
     IL_0081:  stloc.s    V_5
     IL_0083:  ldloc.s    V_8
-    IL_0085:  ldfld      int32 assembly/Test1/X12::item
+    IL_0085:  ldfld      int32 Match01/Test1/X12::item
     IL_008a:  stloc.s    V_6
     IL_008c:  ldloc.s    V_5
     IL_008e:  ldloc.s    V_6
@@ -1209,18 +1175,18 @@
     IL_0099:  ret
 
     IL_009a:  ldarg.0
-    IL_009b:  castclass  assembly/Test1/X13
+    IL_009b:  castclass  Match01/Test1/X13
     IL_00a0:  stloc.s    V_9
     IL_00a2:  ldarg.1
-    IL_00a3:  castclass  assembly/Test1/X13
+    IL_00a3:  castclass  Match01/Test1/X13
     IL_00a8:  stloc.s    V_10
     IL_00aa:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
     IL_00af:  stloc.s    V_4
     IL_00b1:  ldloc.s    V_9
-    IL_00b3:  ldfld      int32 assembly/Test1/X13::item
+    IL_00b3:  ldfld      int32 Match01/Test1/X13::item
     IL_00b8:  stloc.s    V_5
     IL_00ba:  ldloc.s    V_10
-    IL_00bc:  ldfld      int32 assembly/Test1/X13::item
+    IL_00bc:  ldfld      int32 Match01/Test1/X13::item
     IL_00c1:  stloc.s    V_6
     IL_00c3:  ldloc.s    V_5
     IL_00c5:  ldloc.s    V_6
@@ -1232,18 +1198,18 @@
     IL_00d0:  ret
 
     IL_00d1:  ldarg.0
-    IL_00d2:  castclass  assembly/Test1/X14
+    IL_00d2:  castclass  Match01/Test1/X14
     IL_00d7:  stloc.s    V_11
     IL_00d9:  ldarg.1
-    IL_00da:  castclass  assembly/Test1/X14
+    IL_00da:  castclass  Match01/Test1/X14
     IL_00df:  stloc.s    V_12
     IL_00e1:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
     IL_00e6:  stloc.s    V_4
     IL_00e8:  ldloc.s    V_11
-    IL_00ea:  ldfld      int32 assembly/Test1/X14::item
+    IL_00ea:  ldfld      int32 Match01/Test1/X14::item
     IL_00ef:  stloc.s    V_5
     IL_00f1:  ldloc.s    V_12
-    IL_00f3:  ldfld      int32 assembly/Test1/X14::item
+    IL_00f3:  ldfld      int32 Match01/Test1/X14::item
     IL_00f8:  stloc.s    V_6
     IL_00fa:  ldloc.s    V_5
     IL_00fc:  ldloc.s    V_6
@@ -1260,8 +1226,8 @@
     IL_010b:  ret
   } 
 
-  .method assembly static int32  'CompareTo$cont@4-1'(class assembly/Test1 this,
-                                                      class assembly/Test1 objTemp,
+  .method assembly static int32  'CompareTo$cont@4-1'(class Match01/Test1 this,
+                                                      class Match01/Test1 objTemp,
                                                       class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
   {
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -1269,44 +1235,44 @@
     .maxstack  5
     .locals init (int32 V_0,
              int32 V_1,
-             class assembly/Test1/X11 V_2,
-             class assembly/Test1/X11 V_3,
+             class Match01/Test1/X11 V_2,
+             class Match01/Test1/X11 V_3,
              int32 V_4,
              int32 V_5,
-             class assembly/Test1/X12 V_6,
-             class assembly/Test1/X12 V_7,
-             class assembly/Test1/X13 V_8,
-             class assembly/Test1/X13 V_9,
-             class assembly/Test1/X14 V_10,
-             class assembly/Test1/X14 V_11)
+             class Match01/Test1/X12 V_6,
+             class Match01/Test1/X12 V_7,
+             class Match01/Test1/X13 V_8,
+             class Match01/Test1/X13 V_9,
+             class Match01/Test1/X14 V_10,
+             class Match01/Test1/X14 V_11)
     IL_0000:  ldarg.0
-    IL_0001:  ldfld      int32 assembly/Test1::_tag
+    IL_0001:  ldfld      int32 Match01/Test1::_tag
     IL_0006:  stloc.0
     IL_0007:  ldarg.1
-    IL_0008:  ldfld      int32 assembly/Test1::_tag
+    IL_0008:  ldfld      int32 Match01/Test1::_tag
     IL_000d:  stloc.1
     IL_000e:  ldloc.0
     IL_000f:  ldloc.1
     IL_0010:  bne.un     IL_00ec
 
     IL_0015:  ldarg.0
-    IL_0016:  call       instance int32 assembly/Test1::get_Tag()
+    IL_0016:  call       instance int32 Match01/Test1::get_Tag()
     IL_001b:  switch     ( 
                           IL_0030,
                           IL_005c,
                           IL_008c,
                           IL_00bc)
     IL_0030:  ldarg.0
-    IL_0031:  castclass  assembly/Test1/X11
+    IL_0031:  castclass  Match01/Test1/X11
     IL_0036:  stloc.2
     IL_0037:  ldarg.1
-    IL_0038:  castclass  assembly/Test1/X11
+    IL_0038:  castclass  Match01/Test1/X11
     IL_003d:  stloc.3
     IL_003e:  ldloc.2
-    IL_003f:  ldfld      int32 assembly/Test1/X11::item
+    IL_003f:  ldfld      int32 Match01/Test1/X11::item
     IL_0044:  stloc.s    V_4
     IL_0046:  ldloc.3
-    IL_0047:  ldfld      int32 assembly/Test1/X11::item
+    IL_0047:  ldfld      int32 Match01/Test1/X11::item
     IL_004c:  stloc.s    V_5
     IL_004e:  ldloc.s    V_4
     IL_0050:  ldloc.s    V_5
@@ -1318,16 +1284,16 @@
     IL_005b:  ret
 
     IL_005c:  ldarg.0
-    IL_005d:  castclass  assembly/Test1/X12
+    IL_005d:  castclass  Match01/Test1/X12
     IL_0062:  stloc.s    V_6
     IL_0064:  ldarg.1
-    IL_0065:  castclass  assembly/Test1/X12
+    IL_0065:  castclass  Match01/Test1/X12
     IL_006a:  stloc.s    V_7
     IL_006c:  ldloc.s    V_6
-    IL_006e:  ldfld      int32 assembly/Test1/X12::item
+    IL_006e:  ldfld      int32 Match01/Test1/X12::item
     IL_0073:  stloc.s    V_4
     IL_0075:  ldloc.s    V_7
-    IL_0077:  ldfld      int32 assembly/Test1/X12::item
+    IL_0077:  ldfld      int32 Match01/Test1/X12::item
     IL_007c:  stloc.s    V_5
     IL_007e:  ldloc.s    V_4
     IL_0080:  ldloc.s    V_5
@@ -1339,16 +1305,16 @@
     IL_008b:  ret
 
     IL_008c:  ldarg.0
-    IL_008d:  castclass  assembly/Test1/X13
+    IL_008d:  castclass  Match01/Test1/X13
     IL_0092:  stloc.s    V_8
     IL_0094:  ldarg.1
-    IL_0095:  castclass  assembly/Test1/X13
+    IL_0095:  castclass  Match01/Test1/X13
     IL_009a:  stloc.s    V_9
     IL_009c:  ldloc.s    V_8
-    IL_009e:  ldfld      int32 assembly/Test1/X13::item
+    IL_009e:  ldfld      int32 Match01/Test1/X13::item
     IL_00a3:  stloc.s    V_4
     IL_00a5:  ldloc.s    V_9
-    IL_00a7:  ldfld      int32 assembly/Test1/X13::item
+    IL_00a7:  ldfld      int32 Match01/Test1/X13::item
     IL_00ac:  stloc.s    V_5
     IL_00ae:  ldloc.s    V_4
     IL_00b0:  ldloc.s    V_5
@@ -1360,16 +1326,16 @@
     IL_00bb:  ret
 
     IL_00bc:  ldarg.0
-    IL_00bd:  castclass  assembly/Test1/X14
+    IL_00bd:  castclass  Match01/Test1/X14
     IL_00c2:  stloc.s    V_10
     IL_00c4:  ldarg.1
-    IL_00c5:  castclass  assembly/Test1/X14
+    IL_00c5:  castclass  Match01/Test1/X14
     IL_00ca:  stloc.s    V_11
     IL_00cc:  ldloc.s    V_10
-    IL_00ce:  ldfld      int32 assembly/Test1/X14::item
+    IL_00ce:  ldfld      int32 Match01/Test1/X14::item
     IL_00d3:  stloc.s    V_4
     IL_00d5:  ldloc.s    V_11
-    IL_00d7:  ldfld      int32 assembly/Test1/X14::item
+    IL_00d7:  ldfld      int32 Match01/Test1/X14::item
     IL_00dc:  stloc.s    V_5
     IL_00de:  ldloc.s    V_4
     IL_00e0:  ldloc.s    V_5
@@ -1386,21 +1352,21 @@
     IL_00ef:  ret
   } 
 
-  .method public static int32  select1(class assembly/Test1 x) cil managed
+  .method public static int32  select1(class Match01/Test1 x) cil managed
   {
     
     .maxstack  8
     IL_0000:  nop
     IL_0001:  ldarg.0
-    IL_0002:  call       instance int32 assembly/Test1::get_Tag()
+    IL_0002:  call       instance int32 Match01/Test1::get_Tag()
     IL_0007:  switch     ( 
                           IL_001c,
                           IL_0028,
                           IL_002a,
                           IL_002c)
     IL_001c:  ldarg.0
-    IL_001d:  castclass  assembly/Test1/X11
-    IL_0022:  ldfld      int32 assembly/Test1/X11::item
+    IL_001d:  castclass  Match01/Test1/X11
+    IL_0022:  ldfld      int32 Match01/Test1/X11::item
     IL_0027:  ret
 
     IL_0028:  ldc.i4.2
@@ -1413,18 +1379,18 @@
     IL_002d:  ret
   } 
 
-  .method public static int32  fm(class assembly/Test1 y) cil managed
+  .method public static int32  fm(class Match01/Test1 y) cil managed
   {
     
     .maxstack  8
     IL_0000:  ldarg.0
-    IL_0001:  call       int32 assembly::select1(class assembly/Test1)
+    IL_0001:  call       int32 Match01::select1(class Match01/Test1)
     IL_0006:  ret
   } 
 
 } 
 
-.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Match01
        extends [runtime]System.Object
 {
   .method public static void  main@() cil managed
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOff.fs.il.netcore.release.bsl
similarity index 76%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOff.fs.il.netcore.release.bsl
index c6444083260..65aba2a52ca 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01.fs.il.netcore.release.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOff.fs.il.netcore.release.bsl
@@ -39,15 +39,15 @@
 
 
 
-.class public abstract auto ansi sealed assembly
+.class public abstract auto ansi sealed Match01
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
   .class abstract auto autochar serializable nested public beforefieldinit Test1
          extends [runtime]System.Object
-         implements class [runtime]System.IEquatable`1<class assembly/Test1>,
+         implements class [runtime]System.IEquatable`1<class Match01/Test1>,
                     [runtime]System.Collections.IStructuralEquatable,
-                    class [runtime]System.IComparable`1<class assembly/Test1>,
+                    class [runtime]System.IComparable`1<class Match01/Test1>,
                     [runtime]System.IComparable,
                     [runtime]System.Collections.IStructuralComparable
   {
@@ -64,7 +64,7 @@
     } 
 
     .class auto ansi serializable nested public beforefieldinit specialname X11
-           extends assembly/Test1
+           extends Match01/Test1
     {
       .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
                                                                                                                                         2B 58 31 31 40 44 65 62 75 67 54 79 70 65 50 72   
@@ -75,8 +75,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(int32 item) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
       {
         .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -87,22 +86,21 @@
         .maxstack  8
         IL_0000:  ldarg.0
         IL_0001:  ldc.i4.0
-        IL_0002:  call       instance void assembly/Test1::.ctor(int32)
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
         IL_0007:  ldarg.0
         IL_0008:  ldarg.1
-        IL_0009:  stfld      int32 assembly/Test1/X11::item
+        IL_0009:  stfld      int32 Match01/Test1/X11::item
         IL_000e:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      int32 assembly/Test1/X11::item
+        IL_0001:  ldfld      int32 Match01/Test1/X11::item
         IL_0006:  ret
       } 
 
@@ -113,12 +111,12 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X11::get_Item()
+        .get instance int32 Match01/Test1/X11::get_Item()
       } 
     } 
 
     .class auto ansi serializable nested public beforefieldinit specialname X12
-           extends assembly/Test1
+           extends Match01/Test1
     {
       .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
                                                                                                                                         2B 58 31 32 40 44 65 62 75 67 54 79 70 65 50 72   
@@ -129,8 +127,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(int32 item) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
       {
         .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -141,22 +138,21 @@
         .maxstack  8
         IL_0000:  ldarg.0
         IL_0001:  ldc.i4.1
-        IL_0002:  call       instance void assembly/Test1::.ctor(int32)
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
         IL_0007:  ldarg.0
         IL_0008:  ldarg.1
-        IL_0009:  stfld      int32 assembly/Test1/X12::item
+        IL_0009:  stfld      int32 Match01/Test1/X12::item
         IL_000e:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      int32 assembly/Test1/X12::item
+        IL_0001:  ldfld      int32 Match01/Test1/X12::item
         IL_0006:  ret
       } 
 
@@ -167,12 +163,12 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 01 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X12::get_Item()
+        .get instance int32 Match01/Test1/X12::get_Item()
       } 
     } 
 
     .class auto ansi serializable nested public beforefieldinit specialname X13
-           extends assembly/Test1
+           extends Match01/Test1
     {
       .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
                                                                                                                                         2B 58 31 33 40 44 65 62 75 67 54 79 70 65 50 72   
@@ -183,8 +179,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(int32 item) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
       {
         .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -195,22 +190,21 @@
         .maxstack  8
         IL_0000:  ldarg.0
         IL_0001:  ldc.i4.2
-        IL_0002:  call       instance void assembly/Test1::.ctor(int32)
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
         IL_0007:  ldarg.0
         IL_0008:  ldarg.1
-        IL_0009:  stfld      int32 assembly/Test1/X13::item
+        IL_0009:  stfld      int32 Match01/Test1/X13::item
         IL_000e:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      int32 assembly/Test1/X13::item
+        IL_0001:  ldfld      int32 Match01/Test1/X13::item
         IL_0006:  ret
       } 
 
@@ -221,12 +215,12 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 02 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X13::get_Item()
+        .get instance int32 Match01/Test1/X13::get_Item()
       } 
     } 
 
     .class auto ansi serializable nested public beforefieldinit specialname X14
-           extends assembly/Test1
+           extends Match01/Test1
     {
       .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
                                                                                                                                         2B 58 31 34 40 44 65 62 75 67 54 79 70 65 50 72   
@@ -237,8 +231,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(int32 item) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
       {
         .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -249,22 +242,21 @@
         .maxstack  8
         IL_0000:  ldarg.0
         IL_0001:  ldc.i4.3
-        IL_0002:  call       instance void assembly/Test1::.ctor(int32)
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
         IL_0007:  ldarg.0
         IL_0008:  ldarg.1
-        IL_0009:  stfld      int32 assembly/Test1/X14::item
+        IL_0009:  stfld      int32 Match01/Test1/X14::item
         IL_000e:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      int32 assembly/Test1/X14::item
+        IL_0001:  ldfld      int32 Match01/Test1/X14::item
         IL_0006:  ret
       } 
 
@@ -275,19 +267,18 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 03 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X14::get_Item()
+        .get instance int32 Match01/Test1/X14::get_Item()
       } 
     } 
 
     .class auto ansi nested assembly beforefieldinit specialname X11@DebugTypeProxy
            extends [runtime]System.Object
     {
-      .field assembly class assembly/Test1/X11 _obj
+      .field assembly class Match01/Test1/X11 _obj
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method public specialname rtspecialname 
-              instance void  .ctor(class assembly/Test1/X11 obj) cil managed
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X11 obj) cil managed
       {
         .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -300,20 +291,19 @@
         IL_0001:  call       instance void [runtime]System.Object::.ctor()
         IL_0006:  ldarg.0
         IL_0007:  ldarg.1
-        IL_0008:  stfld      class assembly/Test1/X11 assembly/Test1/X11@DebugTypeProxy::_obj
+        IL_0008:  stfld      class Match01/Test1/X11 Match01/Test1/X11@DebugTypeProxy::_obj
         IL_000d:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      class assembly/Test1/X11 assembly/Test1/X11@DebugTypeProxy::_obj
-        IL_0006:  ldfld      int32 assembly/Test1/X11::item
+        IL_0001:  ldfld      class Match01/Test1/X11 Match01/Test1/X11@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X11::item
         IL_000b:  ret
       } 
 
@@ -324,19 +314,18 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X11@DebugTypeProxy::get_Item()
+        .get instance int32 Match01/Test1/X11@DebugTypeProxy::get_Item()
       } 
     } 
 
     .class auto ansi nested assembly beforefieldinit specialname X12@DebugTypeProxy
            extends [runtime]System.Object
     {
-      .field assembly class assembly/Test1/X12 _obj
+      .field assembly class Match01/Test1/X12 _obj
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method public specialname rtspecialname 
-              instance void  .ctor(class assembly/Test1/X12 obj) cil managed
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X12 obj) cil managed
       {
         .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -349,20 +338,19 @@
         IL_0001:  call       instance void [runtime]System.Object::.ctor()
         IL_0006:  ldarg.0
         IL_0007:  ldarg.1
-        IL_0008:  stfld      class assembly/Test1/X12 assembly/Test1/X12@DebugTypeProxy::_obj
+        IL_0008:  stfld      class Match01/Test1/X12 Match01/Test1/X12@DebugTypeProxy::_obj
         IL_000d:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      class assembly/Test1/X12 assembly/Test1/X12@DebugTypeProxy::_obj
-        IL_0006:  ldfld      int32 assembly/Test1/X12::item
+        IL_0001:  ldfld      class Match01/Test1/X12 Match01/Test1/X12@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X12::item
         IL_000b:  ret
       } 
 
@@ -373,19 +361,18 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 01 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X12@DebugTypeProxy::get_Item()
+        .get instance int32 Match01/Test1/X12@DebugTypeProxy::get_Item()
       } 
     } 
 
     .class auto ansi nested assembly beforefieldinit specialname X13@DebugTypeProxy
            extends [runtime]System.Object
     {
-      .field assembly class assembly/Test1/X13 _obj
+      .field assembly class Match01/Test1/X13 _obj
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method public specialname rtspecialname 
-              instance void  .ctor(class assembly/Test1/X13 obj) cil managed
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X13 obj) cil managed
       {
         .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -398,20 +385,19 @@
         IL_0001:  call       instance void [runtime]System.Object::.ctor()
         IL_0006:  ldarg.0
         IL_0007:  ldarg.1
-        IL_0008:  stfld      class assembly/Test1/X13 assembly/Test1/X13@DebugTypeProxy::_obj
+        IL_0008:  stfld      class Match01/Test1/X13 Match01/Test1/X13@DebugTypeProxy::_obj
         IL_000d:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      class assembly/Test1/X13 assembly/Test1/X13@DebugTypeProxy::_obj
-        IL_0006:  ldfld      int32 assembly/Test1/X13::item
+        IL_0001:  ldfld      class Match01/Test1/X13 Match01/Test1/X13@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X13::item
         IL_000b:  ret
       } 
 
@@ -422,19 +408,18 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 02 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X13@DebugTypeProxy::get_Item()
+        .get instance int32 Match01/Test1/X13@DebugTypeProxy::get_Item()
       } 
     } 
 
     .class auto ansi nested assembly beforefieldinit specialname X14@DebugTypeProxy
            extends [runtime]System.Object
     {
-      .field assembly class assembly/Test1/X14 _obj
+      .field assembly class Match01/Test1/X14 _obj
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method public specialname rtspecialname 
-              instance void  .ctor(class assembly/Test1/X14 obj) cil managed
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X14 obj) cil managed
       {
         .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                                 class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -447,20 +432,19 @@
         IL_0001:  call       instance void [runtime]System.Object::.ctor()
         IL_0006:  ldarg.0
         IL_0007:  ldarg.1
-        IL_0008:  stfld      class assembly/Test1/X14 assembly/Test1/X14@DebugTypeProxy::_obj
+        IL_0008:  stfld      class Match01/Test1/X14 Match01/Test1/X14@DebugTypeProxy::_obj
         IL_000d:  ret
       } 
 
-      .method public hidebysig instance int32 
-              get_Item() cil managed
+      .method public hidebysig instance int32 get_Item() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
         
         .maxstack  8
         IL_0000:  ldarg.0
-        IL_0001:  ldfld      class assembly/Test1/X14 assembly/Test1/X14@DebugTypeProxy::_obj
-        IL_0006:  ldfld      int32 assembly/Test1/X14::item
+        IL_0001:  ldfld      class Match01/Test1/X14 Match01/Test1/X14@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X14::item
         IL_000b:  ret
       } 
 
@@ -471,7 +455,7 @@
                                                                                                     int32) = ( 01 00 04 00 00 00 03 00 00 00 00 00 00 00 00 00 ) 
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-        .get instance int32 assembly/Test1/X14@DebugTypeProxy::get_Item()
+        .get instance int32 Match01/Test1/X14@DebugTypeProxy::get_Item()
       } 
     } 
 
@@ -479,8 +463,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(int32 _tag) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(int32 _tag) cil managed
     {
       .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                                               class [runtime]System.Type) = ( 01 00 E0 07 00 00 0D 4D 61 74 63 68 30 31 2B 54   
@@ -493,157 +476,145 @@
       IL_0001:  call       instance void [runtime]System.Object::.ctor()
       IL_0006:  ldarg.0
       IL_0007:  ldarg.1
-      IL_0008:  stfld      int32 assembly/Test1::_tag
+      IL_0008:  stfld      int32 Match01/Test1::_tag
       IL_000d:  ret
     } 
 
-    .method public static class assembly/Test1 
-            NewX11(int32 item) cil managed
+    .method public static class Match01/Test1 NewX11(int32 item) cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  newobj     instance void assembly/Test1/X11::.ctor(int32)
+      IL_0001:  newobj     instance void Match01/Test1/X11::.ctor(int32)
       IL_0006:  ret
     } 
 
-    .method public hidebysig instance bool 
-            get_IsX11() cil managed
+    .method public hidebysig instance bool get_IsX11() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
       IL_0006:  ldc.i4.0
       IL_0007:  ceq
       IL_0009:  ret
     } 
 
-    .method public static class assembly/Test1 
-            NewX12(int32 item) cil managed
+    .method public static class Match01/Test1 NewX12(int32 item) cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 01 00 00 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  newobj     instance void assembly/Test1/X12::.ctor(int32)
+      IL_0001:  newobj     instance void Match01/Test1/X12::.ctor(int32)
       IL_0006:  ret
     } 
 
-    .method public hidebysig instance bool 
-            get_IsX12() cil managed
+    .method public hidebysig instance bool get_IsX12() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
       IL_0006:  ldc.i4.1
       IL_0007:  ceq
       IL_0009:  ret
     } 
 
-    .method public static class assembly/Test1 
-            NewX13(int32 item) cil managed
+    .method public static class Match01/Test1 NewX13(int32 item) cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 02 00 00 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  newobj     instance void assembly/Test1/X13::.ctor(int32)
+      IL_0001:  newobj     instance void Match01/Test1/X13::.ctor(int32)
       IL_0006:  ret
     } 
 
-    .method public hidebysig instance bool 
-            get_IsX13() cil managed
+    .method public hidebysig instance bool get_IsX13() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
       IL_0006:  ldc.i4.2
       IL_0007:  ceq
       IL_0009:  ret
     } 
 
-    .method public static class assembly/Test1 
-            NewX14(int32 item) cil managed
+    .method public static class Match01/Test1 NewX14(int32 item) cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 03 00 00 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  newobj     instance void assembly/Test1/X14::.ctor(int32)
+      IL_0001:  newobj     instance void Match01/Test1/X14::.ctor(int32)
       IL_0006:  ret
     } 
 
-    .method public hidebysig instance bool 
-            get_IsX14() cil managed
+    .method public hidebysig instance bool get_IsX14() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
       IL_0006:  ldc.i4.3
       IL_0007:  ceq
       IL_0009:  ret
     } 
 
-    .method public hidebysig instance int32 
-            get_Tag() cil managed
+    .method public hidebysig instance int32 get_Tag() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
-      IL_0001:  ldfld      int32 assembly/Test1::_tag
+      IL_0001:  ldfld      int32 Match01/Test1::_tag
       IL_0006:  ret
     } 
 
-    .method assembly hidebysig specialname 
-            instance object  __DebugDisplay() cil managed
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldstr      "%+0.8A"
-      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
-      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
       IL_000f:  ldarg.0
-      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>::Invoke(!0)
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>::Invoke(!0)
       IL_0015:  ret
     } 
 
-    .method public strict virtual instance string 
-            ToString() cil managed
+    .method public strict virtual instance string ToString() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldstr      "%+A"
-      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class assembly/Test1>::.ctor(string)
-      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class Match01/Test1>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
       IL_000f:  ldarg.0
-      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Test1,string>::Invoke(!0)
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>::Invoke(!0)
       IL_0015:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(class assembly/Test1 obj) cil managed
+    .method public hidebysig virtual final instance int32  CompareTo(class Match01/Test1 obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -657,8 +628,8 @@
       IL_0006:  ldarg.0
       IL_0007:  ldarg.1
       IL_0008:  ldnull
-      IL_0009:  call       int32 assembly::CompareTo$cont@4(class assembly/Test1,
-                                                           class assembly/Test1,
+      IL_0009:  call       int32 Match01::CompareTo$cont@4(class Match01/Test1,
+                                                           class Match01/Test1,
                                                            class [FSharp.Core]Microsoft.FSharp.Core.Unit)
       IL_000e:  ret
 
@@ -675,16 +646,15 @@
       IL_0017:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(object obj) cil managed
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
       IL_0001:  ldarg.1
-      IL_0002:  unbox.any  assembly/Test1
-      IL_0007:  callvirt   instance int32 assembly/Test1::CompareTo(class assembly/Test1)
+      IL_0002:  unbox.any  Match01/Test1
+      IL_0007:  callvirt   instance int32 Match01/Test1::CompareTo(class Match01/Test1)
       IL_000c:  ret
     } 
 
@@ -695,9 +665,9 @@
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  6
-      .locals init (class assembly/Test1 V_0)
+      .locals init (class Match01/Test1 V_0)
       IL_0000:  ldarg.1
-      IL_0001:  unbox.any  assembly/Test1
+      IL_0001:  unbox.any  Match01/Test1
       IL_0006:  stloc.0
       IL_0007:  ldarg.0
       IL_0008:  brfalse.s  IL_0014
@@ -706,14 +676,14 @@
       IL_000b:  ldarg.1
       IL_000c:  ldloc.0
       IL_000d:  ldnull
-      IL_000e:  call       int32 assembly::'CompareTo$cont@4-1'(class assembly/Test1,
+      IL_000e:  call       int32 Match01::'CompareTo$cont@4-1'(class Match01/Test1,
                                                                object,
-                                                               class assembly/Test1,
+                                                               class Match01/Test1,
                                                                class [FSharp.Core]Microsoft.FSharp.Core.Unit)
       IL_0013:  ret
 
       IL_0014:  ldarg.1
-      IL_0015:  unbox.any  assembly/Test1
+      IL_0015:  unbox.any  Match01/Test1
       IL_001a:  brfalse.s  IL_001e
 
       IL_001c:  ldc.i4.m1
@@ -723,37 +693,36 @@
       IL_001f:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  7
       .locals init (int32 V_0,
-               class assembly/Test1/X11 V_1,
-               class assembly/Test1/X12 V_2,
-               class assembly/Test1/X13 V_3,
-               class assembly/Test1/X14 V_4)
+               class Match01/Test1/X11 V_1,
+               class Match01/Test1/X12 V_2,
+               class Match01/Test1/X13 V_3,
+               class Match01/Test1/X14 V_4)
       IL_0000:  ldarg.0
       IL_0001:  brfalse    IL_00a5
 
       IL_0006:  ldc.i4.0
       IL_0007:  stloc.0
       IL_0008:  ldarg.0
-      IL_0009:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0009:  call       instance int32 Match01/Test1::get_Tag()
       IL_000e:  switch     ( 
                             IL_0023,
                             IL_0043,
                             IL_0063,
                             IL_0083)
       IL_0023:  ldarg.0
-      IL_0024:  castclass  assembly/Test1/X11
+      IL_0024:  castclass  Match01/Test1/X11
       IL_0029:  stloc.1
       IL_002a:  ldc.i4.0
       IL_002b:  stloc.0
       IL_002c:  ldc.i4     0x9e3779b9
       IL_0031:  ldloc.1
-      IL_0032:  ldfld      int32 assembly/Test1/X11::item
+      IL_0032:  ldfld      int32 Match01/Test1/X11::item
       IL_0037:  ldloc.0
       IL_0038:  ldc.i4.6
       IL_0039:  shl
@@ -768,13 +737,13 @@
       IL_0042:  ret
 
       IL_0043:  ldarg.0
-      IL_0044:  castclass  assembly/Test1/X12
+      IL_0044:  castclass  Match01/Test1/X12
       IL_0049:  stloc.2
       IL_004a:  ldc.i4.1
       IL_004b:  stloc.0
       IL_004c:  ldc.i4     0x9e3779b9
       IL_0051:  ldloc.2
-      IL_0052:  ldfld      int32 assembly/Test1/X12::item
+      IL_0052:  ldfld      int32 Match01/Test1/X12::item
       IL_0057:  ldloc.0
       IL_0058:  ldc.i4.6
       IL_0059:  shl
@@ -789,13 +758,13 @@
       IL_0062:  ret
 
       IL_0063:  ldarg.0
-      IL_0064:  castclass  assembly/Test1/X13
+      IL_0064:  castclass  Match01/Test1/X13
       IL_0069:  stloc.3
       IL_006a:  ldc.i4.2
       IL_006b:  stloc.0
       IL_006c:  ldc.i4     0x9e3779b9
       IL_0071:  ldloc.3
-      IL_0072:  ldfld      int32 assembly/Test1/X13::item
+      IL_0072:  ldfld      int32 Match01/Test1/X13::item
       IL_0077:  ldloc.0
       IL_0078:  ldc.i4.6
       IL_0079:  shl
@@ -810,13 +779,13 @@
       IL_0082:  ret
 
       IL_0083:  ldarg.0
-      IL_0084:  castclass  assembly/Test1/X14
+      IL_0084:  castclass  Match01/Test1/X14
       IL_0089:  stloc.s    V_4
       IL_008b:  ldc.i4.3
       IL_008c:  stloc.0
       IL_008d:  ldc.i4     0x9e3779b9
       IL_0092:  ldloc.s    V_4
-      IL_0094:  ldfld      int32 assembly/Test1/X14::item
+      IL_0094:  ldfld      int32 Match01/Test1/X14::item
       IL_0099:  ldloc.0
       IL_009a:  ldc.i4.6
       IL_009b:  shl
@@ -834,15 +803,14 @@
       IL_00a6:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode() cil managed
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  8
       IL_0000:  ldarg.0
       IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
-      IL_0006:  callvirt   instance int32 assembly/Test1::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_0006:  callvirt   instance int32 Match01/Test1::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
       IL_000b:  ret
     } 
 
@@ -853,92 +821,92 @@
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  4
-      .locals init (class assembly/Test1 V_0,
+      .locals init (class Match01/Test1 V_0,
                int32 V_1,
                int32 V_2,
-               class assembly/Test1/X11 V_3,
-               class assembly/Test1/X11 V_4,
-               class assembly/Test1/X12 V_5,
-               class assembly/Test1/X12 V_6,
-               class assembly/Test1/X13 V_7,
-               class assembly/Test1/X13 V_8,
-               class assembly/Test1/X14 V_9,
-               class assembly/Test1/X14 V_10)
+               class Match01/Test1/X11 V_3,
+               class Match01/Test1/X11 V_4,
+               class Match01/Test1/X12 V_5,
+               class Match01/Test1/X12 V_6,
+               class Match01/Test1/X13 V_7,
+               class Match01/Test1/X13 V_8,
+               class Match01/Test1/X14 V_9,
+               class Match01/Test1/X14 V_10)
       IL_0000:  ldarg.0
       IL_0001:  brfalse    IL_00c9
 
       IL_0006:  ldarg.1
-      IL_0007:  isinst     assembly/Test1
+      IL_0007:  isinst     Match01/Test1
       IL_000c:  stloc.0
       IL_000d:  ldloc.0
       IL_000e:  brfalse    IL_00c7
 
       IL_0013:  ldarg.0
-      IL_0014:  ldfld      int32 assembly/Test1::_tag
+      IL_0014:  ldfld      int32 Match01/Test1::_tag
       IL_0019:  stloc.1
       IL_001a:  ldloc.0
-      IL_001b:  ldfld      int32 assembly/Test1::_tag
+      IL_001b:  ldfld      int32 Match01/Test1::_tag
       IL_0020:  stloc.2
       IL_0021:  ldloc.1
       IL_0022:  ldloc.2
       IL_0023:  bne.un     IL_00c5
 
       IL_0028:  ldarg.0
-      IL_0029:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0029:  call       instance int32 Match01/Test1::get_Tag()
       IL_002e:  switch     ( 
                             IL_0043,
                             IL_0062,
                             IL_0083,
                             IL_00a4)
       IL_0043:  ldarg.0
-      IL_0044:  castclass  assembly/Test1/X11
+      IL_0044:  castclass  Match01/Test1/X11
       IL_0049:  stloc.3
       IL_004a:  ldloc.0
-      IL_004b:  castclass  assembly/Test1/X11
+      IL_004b:  castclass  Match01/Test1/X11
       IL_0050:  stloc.s    V_4
       IL_0052:  ldloc.3
-      IL_0053:  ldfld      int32 assembly/Test1/X11::item
+      IL_0053:  ldfld      int32 Match01/Test1/X11::item
       IL_0058:  ldloc.s    V_4
-      IL_005a:  ldfld      int32 assembly/Test1/X11::item
+      IL_005a:  ldfld      int32 Match01/Test1/X11::item
       IL_005f:  ceq
       IL_0061:  ret
 
       IL_0062:  ldarg.0
-      IL_0063:  castclass  assembly/Test1/X12
+      IL_0063:  castclass  Match01/Test1/X12
       IL_0068:  stloc.s    V_5
       IL_006a:  ldloc.0
-      IL_006b:  castclass  assembly/Test1/X12
+      IL_006b:  castclass  Match01/Test1/X12
       IL_0070:  stloc.s    V_6
       IL_0072:  ldloc.s    V_5
-      IL_0074:  ldfld      int32 assembly/Test1/X12::item
+      IL_0074:  ldfld      int32 Match01/Test1/X12::item
       IL_0079:  ldloc.s    V_6
-      IL_007b:  ldfld      int32 assembly/Test1/X12::item
+      IL_007b:  ldfld      int32 Match01/Test1/X12::item
       IL_0080:  ceq
       IL_0082:  ret
 
       IL_0083:  ldarg.0
-      IL_0084:  castclass  assembly/Test1/X13
+      IL_0084:  castclass  Match01/Test1/X13
       IL_0089:  stloc.s    V_7
       IL_008b:  ldloc.0
-      IL_008c:  castclass  assembly/Test1/X13
+      IL_008c:  castclass  Match01/Test1/X13
       IL_0091:  stloc.s    V_8
       IL_0093:  ldloc.s    V_7
-      IL_0095:  ldfld      int32 assembly/Test1/X13::item
+      IL_0095:  ldfld      int32 Match01/Test1/X13::item
       IL_009a:  ldloc.s    V_8
-      IL_009c:  ldfld      int32 assembly/Test1/X13::item
+      IL_009c:  ldfld      int32 Match01/Test1/X13::item
       IL_00a1:  ceq
       IL_00a3:  ret
 
       IL_00a4:  ldarg.0
-      IL_00a5:  castclass  assembly/Test1/X14
+      IL_00a5:  castclass  Match01/Test1/X14
       IL_00aa:  stloc.s    V_9
       IL_00ac:  ldloc.0
-      IL_00ad:  castclass  assembly/Test1/X14
+      IL_00ad:  castclass  Match01/Test1/X14
       IL_00b2:  stloc.s    V_10
       IL_00b4:  ldloc.s    V_9
-      IL_00b6:  ldfld      int32 assembly/Test1/X14::item
+      IL_00b6:  ldfld      int32 Match01/Test1/X14::item
       IL_00bb:  ldloc.s    V_10
-      IL_00bd:  ldfld      int32 assembly/Test1/X14::item
+      IL_00bd:  ldfld      int32 Match01/Test1/X14::item
       IL_00c2:  ceq
       IL_00c4:  ret
 
@@ -956,22 +924,21 @@
       IL_00d0:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance bool  Equals(class assembly/Test1 obj) cil managed
+    .method public hidebysig virtual final instance bool  Equals(class Match01/Test1 obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  4
       .locals init (int32 V_0,
                int32 V_1,
-               class assembly/Test1/X11 V_2,
-               class assembly/Test1/X11 V_3,
-               class assembly/Test1/X12 V_4,
-               class assembly/Test1/X12 V_5,
-               class assembly/Test1/X13 V_6,
-               class assembly/Test1/X13 V_7,
-               class assembly/Test1/X14 V_8,
-               class assembly/Test1/X14 V_9)
+               class Match01/Test1/X11 V_2,
+               class Match01/Test1/X11 V_3,
+               class Match01/Test1/X12 V_4,
+               class Match01/Test1/X12 V_5,
+               class Match01/Test1/X13 V_6,
+               class Match01/Test1/X13 V_7,
+               class Match01/Test1/X14 V_8,
+               class Match01/Test1/X14 V_9)
       IL_0000:  ldarg.0
       IL_0001:  brfalse    IL_00c0
 
@@ -979,71 +946,71 @@
       IL_0007:  brfalse    IL_00be
 
       IL_000c:  ldarg.0
-      IL_000d:  ldfld      int32 assembly/Test1::_tag
+      IL_000d:  ldfld      int32 Match01/Test1::_tag
       IL_0012:  stloc.0
       IL_0013:  ldarg.1
-      IL_0014:  ldfld      int32 assembly/Test1::_tag
+      IL_0014:  ldfld      int32 Match01/Test1::_tag
       IL_0019:  stloc.1
       IL_001a:  ldloc.0
       IL_001b:  ldloc.1
       IL_001c:  bne.un     IL_00bc
 
       IL_0021:  ldarg.0
-      IL_0022:  call       instance int32 assembly/Test1::get_Tag()
+      IL_0022:  call       instance int32 Match01/Test1::get_Tag()
       IL_0027:  switch     ( 
                             IL_003c,
                             IL_0059,
                             IL_007a,
                             IL_009b)
       IL_003c:  ldarg.0
-      IL_003d:  castclass  assembly/Test1/X11
+      IL_003d:  castclass  Match01/Test1/X11
       IL_0042:  stloc.2
       IL_0043:  ldarg.1
-      IL_0044:  castclass  assembly/Test1/X11
+      IL_0044:  castclass  Match01/Test1/X11
       IL_0049:  stloc.3
       IL_004a:  ldloc.2
-      IL_004b:  ldfld      int32 assembly/Test1/X11::item
+      IL_004b:  ldfld      int32 Match01/Test1/X11::item
       IL_0050:  ldloc.3
-      IL_0051:  ldfld      int32 assembly/Test1/X11::item
+      IL_0051:  ldfld      int32 Match01/Test1/X11::item
       IL_0056:  ceq
       IL_0058:  ret
 
       IL_0059:  ldarg.0
-      IL_005a:  castclass  assembly/Test1/X12
+      IL_005a:  castclass  Match01/Test1/X12
       IL_005f:  stloc.s    V_4
       IL_0061:  ldarg.1
-      IL_0062:  castclass  assembly/Test1/X12
+      IL_0062:  castclass  Match01/Test1/X12
       IL_0067:  stloc.s    V_5
       IL_0069:  ldloc.s    V_4
-      IL_006b:  ldfld      int32 assembly/Test1/X12::item
+      IL_006b:  ldfld      int32 Match01/Test1/X12::item
       IL_0070:  ldloc.s    V_5
-      IL_0072:  ldfld      int32 assembly/Test1/X12::item
+      IL_0072:  ldfld      int32 Match01/Test1/X12::item
       IL_0077:  ceq
       IL_0079:  ret
 
       IL_007a:  ldarg.0
-      IL_007b:  castclass  assembly/Test1/X13
+      IL_007b:  castclass  Match01/Test1/X13
       IL_0080:  stloc.s    V_6
       IL_0082:  ldarg.1
-      IL_0083:  castclass  assembly/Test1/X13
+      IL_0083:  castclass  Match01/Test1/X13
       IL_0088:  stloc.s    V_7
       IL_008a:  ldloc.s    V_6
-      IL_008c:  ldfld      int32 assembly/Test1/X13::item
+      IL_008c:  ldfld      int32 Match01/Test1/X13::item
       IL_0091:  ldloc.s    V_7
-      IL_0093:  ldfld      int32 assembly/Test1/X13::item
+      IL_0093:  ldfld      int32 Match01/Test1/X13::item
       IL_0098:  ceq
       IL_009a:  ret
 
       IL_009b:  ldarg.0
-      IL_009c:  castclass  assembly/Test1/X14
+      IL_009c:  castclass  Match01/Test1/X14
       IL_00a1:  stloc.s    V_8
       IL_00a3:  ldarg.1
-      IL_00a4:  castclass  assembly/Test1/X14
+      IL_00a4:  castclass  Match01/Test1/X14
       IL_00a9:  stloc.s    V_9
       IL_00ab:  ldloc.s    V_8
-      IL_00ad:  ldfld      int32 assembly/Test1/X14::item
+      IL_00ad:  ldfld      int32 Match01/Test1/X14::item
       IL_00b2:  ldloc.s    V_9
-      IL_00b4:  ldfld      int32 assembly/Test1/X14::item
+      IL_00b4:  ldfld      int32 Match01/Test1/X14::item
       IL_00b9:  ceq
       IL_00bb:  ret
 
@@ -1061,22 +1028,21 @@
       IL_00c7:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance bool  Equals(object obj) cil managed
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
       .maxstack  4
-      .locals init (class assembly/Test1 V_0)
+      .locals init (class Match01/Test1 V_0)
       IL_0000:  ldarg.1
-      IL_0001:  isinst     assembly/Test1
+      IL_0001:  isinst     Match01/Test1
       IL_0006:  stloc.0
       IL_0007:  ldloc.0
       IL_0008:  brfalse.s  IL_0012
 
       IL_000a:  ldarg.0
       IL_000b:  ldloc.0
-      IL_000c:  callvirt   instance bool assembly/Test1::Equals(class assembly/Test1)
+      IL_000c:  callvirt   instance bool Match01/Test1::Equals(class Match01/Test1)
       IL_0011:  ret
 
       IL_0012:  ldc.i4.0
@@ -1088,40 +1054,40 @@
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance int32 assembly/Test1::get_Tag()
+      .get instance int32 Match01/Test1::get_Tag()
     } 
     .property instance bool IsX11()
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance bool assembly/Test1::get_IsX11()
+      .get instance bool Match01/Test1::get_IsX11()
     } 
     .property instance bool IsX12()
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance bool assembly/Test1::get_IsX12()
+      .get instance bool Match01/Test1::get_IsX12()
     } 
     .property instance bool IsX13()
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance bool assembly/Test1::get_IsX13()
+      .get instance bool Match01/Test1::get_IsX13()
     } 
     .property instance bool IsX14()
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-      .get instance bool assembly/Test1::get_IsX14()
+      .get instance bool Match01/Test1::get_IsX14()
     } 
   } 
 
-  .method assembly static int32  CompareTo$cont@4(class assembly/Test1 this,
-                                                  class assembly/Test1 obj,
+  .method assembly static int32  CompareTo$cont@4(class Match01/Test1 this,
+                                                  class Match01/Test1 obj,
                                                   class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
   {
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -1129,47 +1095,47 @@
     .maxstack  5
     .locals init (int32 V_0,
              int32 V_1,
-             class assembly/Test1/X11 V_2,
-             class assembly/Test1/X11 V_3,
+             class Match01/Test1/X11 V_2,
+             class Match01/Test1/X11 V_3,
              class [runtime]System.Collections.IComparer V_4,
              int32 V_5,
              int32 V_6,
-             class assembly/Test1/X12 V_7,
-             class assembly/Test1/X12 V_8,
-             class assembly/Test1/X13 V_9,
-             class assembly/Test1/X13 V_10,
-             class assembly/Test1/X14 V_11,
-             class assembly/Test1/X14 V_12)
+             class Match01/Test1/X12 V_7,
+             class Match01/Test1/X12 V_8,
+             class Match01/Test1/X13 V_9,
+             class Match01/Test1/X13 V_10,
+             class Match01/Test1/X14 V_11,
+             class Match01/Test1/X14 V_12)
     IL_0000:  ldarg.0
-    IL_0001:  ldfld      int32 assembly/Test1::_tag
+    IL_0001:  ldfld      int32 Match01/Test1::_tag
     IL_0006:  stloc.0
     IL_0007:  ldarg.1
-    IL_0008:  ldfld      int32 assembly/Test1::_tag
+    IL_0008:  ldfld      int32 Match01/Test1::_tag
     IL_000d:  stloc.1
     IL_000e:  ldloc.0
     IL_000f:  ldloc.1
     IL_0010:  bne.un     IL_0108
 
     IL_0015:  ldarg.0
-    IL_0016:  call       instance int32 assembly/Test1::get_Tag()
+    IL_0016:  call       instance int32 Match01/Test1::get_Tag()
     IL_001b:  switch     ( 
                           IL_0030,
                           IL_0063,
                           IL_009a,
                           IL_00d1)
     IL_0030:  ldarg.0
-    IL_0031:  castclass  assembly/Test1/X11
+    IL_0031:  castclass  Match01/Test1/X11
     IL_0036:  stloc.2
     IL_0037:  ldarg.1
-    IL_0038:  castclass  assembly/Test1/X11
+    IL_0038:  castclass  Match01/Test1/X11
     IL_003d:  stloc.3
     IL_003e:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
     IL_0043:  stloc.s    V_4
     IL_0045:  ldloc.2
-    IL_0046:  ldfld      int32 assembly/Test1/X11::item
+    IL_0046:  ldfld      int32 Match01/Test1/X11::item
     IL_004b:  stloc.s    V_5
     IL_004d:  ldloc.3
-    IL_004e:  ldfld      int32 assembly/Test1/X11::item
+    IL_004e:  ldfld      int32 Match01/Test1/X11::item
     IL_0053:  stloc.s    V_6
     IL_0055:  ldloc.s    V_5
     IL_0057:  ldloc.s    V_6
@@ -1181,18 +1147,18 @@
     IL_0062:  ret
 
     IL_0063:  ldarg.0
-    IL_0064:  castclass  assembly/Test1/X12
+    IL_0064:  castclass  Match01/Test1/X12
     IL_0069:  stloc.s    V_7
     IL_006b:  ldarg.1
-    IL_006c:  castclass  assembly/Test1/X12
+    IL_006c:  castclass  Match01/Test1/X12
     IL_0071:  stloc.s    V_8
     IL_0073:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
     IL_0078:  stloc.s    V_4
     IL_007a:  ldloc.s    V_7
-    IL_007c:  ldfld      int32 assembly/Test1/X12::item
+    IL_007c:  ldfld      int32 Match01/Test1/X12::item
     IL_0081:  stloc.s    V_5
     IL_0083:  ldloc.s    V_8
-    IL_0085:  ldfld      int32 assembly/Test1/X12::item
+    IL_0085:  ldfld      int32 Match01/Test1/X12::item
     IL_008a:  stloc.s    V_6
     IL_008c:  ldloc.s    V_5
     IL_008e:  ldloc.s    V_6
@@ -1204,18 +1170,18 @@
     IL_0099:  ret
 
     IL_009a:  ldarg.0
-    IL_009b:  castclass  assembly/Test1/X13
+    IL_009b:  castclass  Match01/Test1/X13
     IL_00a0:  stloc.s    V_9
     IL_00a2:  ldarg.1
-    IL_00a3:  castclass  assembly/Test1/X13
+    IL_00a3:  castclass  Match01/Test1/X13
     IL_00a8:  stloc.s    V_10
     IL_00aa:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
     IL_00af:  stloc.s    V_4
     IL_00b1:  ldloc.s    V_9
-    IL_00b3:  ldfld      int32 assembly/Test1/X13::item
+    IL_00b3:  ldfld      int32 Match01/Test1/X13::item
     IL_00b8:  stloc.s    V_5
     IL_00ba:  ldloc.s    V_10
-    IL_00bc:  ldfld      int32 assembly/Test1/X13::item
+    IL_00bc:  ldfld      int32 Match01/Test1/X13::item
     IL_00c1:  stloc.s    V_6
     IL_00c3:  ldloc.s    V_5
     IL_00c5:  ldloc.s    V_6
@@ -1227,18 +1193,18 @@
     IL_00d0:  ret
 
     IL_00d1:  ldarg.0
-    IL_00d2:  castclass  assembly/Test1/X14
+    IL_00d2:  castclass  Match01/Test1/X14
     IL_00d7:  stloc.s    V_11
     IL_00d9:  ldarg.1
-    IL_00da:  castclass  assembly/Test1/X14
+    IL_00da:  castclass  Match01/Test1/X14
     IL_00df:  stloc.s    V_12
     IL_00e1:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
     IL_00e6:  stloc.s    V_4
     IL_00e8:  ldloc.s    V_11
-    IL_00ea:  ldfld      int32 assembly/Test1/X14::item
+    IL_00ea:  ldfld      int32 Match01/Test1/X14::item
     IL_00ef:  stloc.s    V_5
     IL_00f1:  ldloc.s    V_12
-    IL_00f3:  ldfld      int32 assembly/Test1/X14::item
+    IL_00f3:  ldfld      int32 Match01/Test1/X14::item
     IL_00f8:  stloc.s    V_6
     IL_00fa:  ldloc.s    V_5
     IL_00fc:  ldloc.s    V_6
@@ -1255,9 +1221,9 @@
     IL_010b:  ret
   } 
 
-  .method assembly static int32  'CompareTo$cont@4-1'(class assembly/Test1 this,
+  .method assembly static int32  'CompareTo$cont@4-1'(class Match01/Test1 this,
                                                       object obj,
-                                                      class assembly/Test1 objTemp,
+                                                      class Match01/Test1 objTemp,
                                                       class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
   {
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -1265,48 +1231,48 @@
     .maxstack  5
     .locals init (int32 V_0,
              int32 V_1,
-             class assembly/Test1/X11 V_2,
-             class assembly/Test1/X11 V_3,
+             class Match01/Test1/X11 V_2,
+             class Match01/Test1/X11 V_3,
              int32 V_4,
              int32 V_5,
-             class assembly/Test1/X12 V_6,
-             class assembly/Test1/X12 V_7,
-             class assembly/Test1/X13 V_8,
-             class assembly/Test1/X13 V_9,
-             class assembly/Test1/X14 V_10,
-             class assembly/Test1/X14 V_11)
+             class Match01/Test1/X12 V_6,
+             class Match01/Test1/X12 V_7,
+             class Match01/Test1/X13 V_8,
+             class Match01/Test1/X13 V_9,
+             class Match01/Test1/X14 V_10,
+             class Match01/Test1/X14 V_11)
     IL_0000:  ldarg.1
-    IL_0001:  unbox.any  assembly/Test1
+    IL_0001:  unbox.any  Match01/Test1
     IL_0006:  brfalse    IL_00fb
 
     IL_000b:  ldarg.0
-    IL_000c:  ldfld      int32 assembly/Test1::_tag
+    IL_000c:  ldfld      int32 Match01/Test1::_tag
     IL_0011:  stloc.0
     IL_0012:  ldarg.2
-    IL_0013:  ldfld      int32 assembly/Test1::_tag
+    IL_0013:  ldfld      int32 Match01/Test1::_tag
     IL_0018:  stloc.1
     IL_0019:  ldloc.0
     IL_001a:  ldloc.1
     IL_001b:  bne.un     IL_00f7
 
     IL_0020:  ldarg.0
-    IL_0021:  call       instance int32 assembly/Test1::get_Tag()
+    IL_0021:  call       instance int32 Match01/Test1::get_Tag()
     IL_0026:  switch     ( 
                           IL_003b,
                           IL_0067,
                           IL_0097,
                           IL_00c7)
     IL_003b:  ldarg.0
-    IL_003c:  castclass  assembly/Test1/X11
+    IL_003c:  castclass  Match01/Test1/X11
     IL_0041:  stloc.2
     IL_0042:  ldarg.2
-    IL_0043:  castclass  assembly/Test1/X11
+    IL_0043:  castclass  Match01/Test1/X11
     IL_0048:  stloc.3
     IL_0049:  ldloc.2
-    IL_004a:  ldfld      int32 assembly/Test1/X11::item
+    IL_004a:  ldfld      int32 Match01/Test1/X11::item
     IL_004f:  stloc.s    V_4
     IL_0051:  ldloc.3
-    IL_0052:  ldfld      int32 assembly/Test1/X11::item
+    IL_0052:  ldfld      int32 Match01/Test1/X11::item
     IL_0057:  stloc.s    V_5
     IL_0059:  ldloc.s    V_4
     IL_005b:  ldloc.s    V_5
@@ -1318,16 +1284,16 @@
     IL_0066:  ret
 
     IL_0067:  ldarg.0
-    IL_0068:  castclass  assembly/Test1/X12
+    IL_0068:  castclass  Match01/Test1/X12
     IL_006d:  stloc.s    V_6
     IL_006f:  ldarg.2
-    IL_0070:  castclass  assembly/Test1/X12
+    IL_0070:  castclass  Match01/Test1/X12
     IL_0075:  stloc.s    V_7
     IL_0077:  ldloc.s    V_6
-    IL_0079:  ldfld      int32 assembly/Test1/X12::item
+    IL_0079:  ldfld      int32 Match01/Test1/X12::item
     IL_007e:  stloc.s    V_4
     IL_0080:  ldloc.s    V_7
-    IL_0082:  ldfld      int32 assembly/Test1/X12::item
+    IL_0082:  ldfld      int32 Match01/Test1/X12::item
     IL_0087:  stloc.s    V_5
     IL_0089:  ldloc.s    V_4
     IL_008b:  ldloc.s    V_5
@@ -1339,16 +1305,16 @@
     IL_0096:  ret
 
     IL_0097:  ldarg.0
-    IL_0098:  castclass  assembly/Test1/X13
+    IL_0098:  castclass  Match01/Test1/X13
     IL_009d:  stloc.s    V_8
     IL_009f:  ldarg.2
-    IL_00a0:  castclass  assembly/Test1/X13
+    IL_00a0:  castclass  Match01/Test1/X13
     IL_00a5:  stloc.s    V_9
     IL_00a7:  ldloc.s    V_8
-    IL_00a9:  ldfld      int32 assembly/Test1/X13::item
+    IL_00a9:  ldfld      int32 Match01/Test1/X13::item
     IL_00ae:  stloc.s    V_4
     IL_00b0:  ldloc.s    V_9
-    IL_00b2:  ldfld      int32 assembly/Test1/X13::item
+    IL_00b2:  ldfld      int32 Match01/Test1/X13::item
     IL_00b7:  stloc.s    V_5
     IL_00b9:  ldloc.s    V_4
     IL_00bb:  ldloc.s    V_5
@@ -1360,16 +1326,16 @@
     IL_00c6:  ret
 
     IL_00c7:  ldarg.0
-    IL_00c8:  castclass  assembly/Test1/X14
+    IL_00c8:  castclass  Match01/Test1/X14
     IL_00cd:  stloc.s    V_10
     IL_00cf:  ldarg.2
-    IL_00d0:  castclass  assembly/Test1/X14
+    IL_00d0:  castclass  Match01/Test1/X14
     IL_00d5:  stloc.s    V_11
     IL_00d7:  ldloc.s    V_10
-    IL_00d9:  ldfld      int32 assembly/Test1/X14::item
+    IL_00d9:  ldfld      int32 Match01/Test1/X14::item
     IL_00de:  stloc.s    V_4
     IL_00e0:  ldloc.s    V_11
-    IL_00e2:  ldfld      int32 assembly/Test1/X14::item
+    IL_00e2:  ldfld      int32 Match01/Test1/X14::item
     IL_00e7:  stloc.s    V_5
     IL_00e9:  ldloc.s    V_4
     IL_00eb:  ldloc.s    V_5
@@ -1389,21 +1355,21 @@
     IL_00fc:  ret
   } 
 
-  .method public static int32  select1(class assembly/Test1 x) cil managed
+  .method public static int32  select1(class Match01/Test1 x) cil managed
   {
     
     .maxstack  8
     IL_0000:  nop
     IL_0001:  ldarg.0
-    IL_0002:  call       instance int32 assembly/Test1::get_Tag()
+    IL_0002:  call       instance int32 Match01/Test1::get_Tag()
     IL_0007:  switch     ( 
                           IL_001c,
                           IL_0028,
                           IL_002a,
                           IL_002c)
     IL_001c:  ldarg.0
-    IL_001d:  castclass  assembly/Test1/X11
-    IL_0022:  ldfld      int32 assembly/Test1/X11::item
+    IL_001d:  castclass  Match01/Test1/X11
+    IL_0022:  ldfld      int32 Match01/Test1/X11::item
     IL_0027:  ret
 
     IL_0028:  ldc.i4.2
@@ -1416,18 +1382,18 @@
     IL_002d:  ret
   } 
 
-  .method public static int32  fm(class assembly/Test1 y) cil managed
+  .method public static int32  fm(class Match01/Test1 y) cil managed
   {
     
     .maxstack  8
     IL_0000:  ldarg.0
-    IL_0001:  call       int32 assembly::select1(class assembly/Test1)
+    IL_0001:  call       int32 Match01::select1(class Match01/Test1)
     IL_0006:  ret
   } 
 
 } 
 
-.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Match01
        extends [runtime]System.Object
 {
   .method public static void  main@() cil managed
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOn.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOn.fs
new file mode 100644
index 00000000000..455b569c200
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOn.fs
@@ -0,0 +1,18 @@
+// #NoMono #CodeGen #Optimizations 
+module Match01
+
+type Test1 = 
+   | X11 of int 
+   | X12 of int 
+   | X13 of int 
+   | X14 of int 
+
+let select1 x = 
+   match x with 
+   | X11 x1 -> x1
+   | X12 _ -> 2 
+   | X13 _ -> 3 
+   | X14 _ -> 4
+
+// select1 is not supposed to be inlined here
+let fm y = select1 y
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOn.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOn.fs.il.net472.debug.bsl
new file mode 100644
index 00000000000..3e70be9b6f3
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOn.fs.il.net472.debug.bsl
@@ -0,0 +1,1590 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Match01
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto autochar serializable nested public beforefieldinit Test1
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class Match01/Test1>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class Match01/Test1>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                   61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .class abstract auto ansi sealed nested public Tags
+           extends [runtime]System.Object
+    {
+      .field public static literal int32 X11 = int32(0x00000000)
+      .field public static literal int32 X12 = int32(0x00000001)
+      .field public static literal int32 X13 = int32(0x00000002)
+      .field public static literal int32 X14 = int32(0x00000003)
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit specialname X11
+           extends Match01/Test1
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
+                                                                                                                            2B 58 31 31 40 44 65 62 75 67 54 79 70 65 50 72   
+                                                                                                                            6F 78 79 00 00 )                                  
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                     61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                 65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.0
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.1
+        IL_0009:  stfld      int32 Match01/Test1/X11::item
+        IL_000e:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 Match01/Test1/X11::item
+        IL_0006:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X11::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit specialname X12
+           extends Match01/Test1
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
+                                                                                                                            2B 58 31 32 40 44 65 62 75 67 54 79 70 65 50 72   
+                                                                                                                            6F 78 79 00 00 )                                  
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                     61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                 65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.1
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.1
+        IL_0009:  stfld      int32 Match01/Test1/X12::item
+        IL_000e:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 Match01/Test1/X12::item
+        IL_0006:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 01 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X12::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit specialname X13
+           extends Match01/Test1
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
+                                                                                                                            2B 58 31 33 40 44 65 62 75 67 54 79 70 65 50 72   
+                                                                                                                            6F 78 79 00 00 )                                  
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                     61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                 65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.2
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.1
+        IL_0009:  stfld      int32 Match01/Test1/X13::item
+        IL_000e:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 Match01/Test1/X13::item
+        IL_0006:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 02 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X13::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit specialname X14
+           extends Match01/Test1
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
+                                                                                                                            2B 58 31 34 40 44 65 62 75 67 54 79 70 65 50 72   
+                                                                                                                            6F 78 79 00 00 )                                  
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                     61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                 65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.3
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.1
+        IL_0009:  stfld      int32 Match01/Test1/X14::item
+        IL_000e:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 Match01/Test1/X14::item
+        IL_0006:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 03 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X14::get_Item()
+      } 
+    } 
+
+    .class auto ansi nested assembly beforefieldinit specialname X11@DebugTypeProxy
+           extends [runtime]System.Object
+    {
+      .field assembly class Match01/Test1/X11 _obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X11 obj) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                 65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1/X11 Match01/Test1/X11@DebugTypeProxy::_obj
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1/X11 Match01/Test1/X11@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X11::item
+        IL_000b:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X11@DebugTypeProxy::get_Item()
+      } 
+    } 
+
+    .class auto ansi nested assembly beforefieldinit specialname X12@DebugTypeProxy
+           extends [runtime]System.Object
+    {
+      .field assembly class Match01/Test1/X12 _obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X12 obj) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                 65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1/X12 Match01/Test1/X12@DebugTypeProxy::_obj
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1/X12 Match01/Test1/X12@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X12::item
+        IL_000b:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 01 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X12@DebugTypeProxy::get_Item()
+      } 
+    } 
+
+    .class auto ansi nested assembly beforefieldinit specialname X13@DebugTypeProxy
+           extends [runtime]System.Object
+    {
+      .field assembly class Match01/Test1/X13 _obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X13 obj) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                 65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1/X13 Match01/Test1/X13@DebugTypeProxy::_obj
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1/X13 Match01/Test1/X13@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X13::item
+        IL_000b:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 02 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X13@DebugTypeProxy::get_Item()
+      } 
+    } 
+
+    .class auto ansi nested assembly beforefieldinit specialname X14@DebugTypeProxy
+           extends [runtime]System.Object
+    {
+      .field assembly class Match01/Test1/X14 _obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X14 obj) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                 65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1/X14 Match01/Test1/X14@DebugTypeProxy::_obj
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1/X14 Match01/Test1/X14@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X14::item
+        IL_000b:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 03 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X14@DebugTypeProxy::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit clo@4
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>
+    {
+      .field public class Match01/Test1 this
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class Match01/Test1 obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class Match01/Test1 this,
+                                   class Match01/Test1 obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance int32 Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 int32 V_1,
+                 class Match01/Test1/X11 V_2,
+                 class Match01/Test1/X11 V_3,
+                 class [runtime]System.Collections.IComparer V_4,
+                 int32 V_5,
+                 int32 V_6,
+                 class Match01/Test1/X12 V_7,
+                 class Match01/Test1/X12 V_8,
+                 class Match01/Test1/X13 V_9,
+                 class Match01/Test1/X13 V_10,
+                 class Match01/Test1/X14 V_11,
+                 class Match01/Test1/X14 V_12)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0006:  ldfld      int32 Match01/Test1::_tag
+        IL_000b:  stloc.0
+        IL_000c:  ldarg.0
+        IL_000d:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_0012:  ldfld      int32 Match01/Test1::_tag
+        IL_0017:  stloc.1
+        IL_0018:  ldloc.0
+        IL_0019:  ldloc.1
+        IL_001a:  bne.un     IL_013f
+
+        IL_001f:  ldarg.0
+        IL_0020:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0025:  call       instance int32 Match01/Test1::get_Tag()
+        IL_002a:  switch     ( 
+                              IL_003f,
+                              IL_007c,
+                              IL_00bd,
+                              IL_00fe)
+        IL_003f:  ldarg.0
+        IL_0040:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0045:  castclass  Match01/Test1/X11
+        IL_004a:  stloc.2
+        IL_004b:  ldarg.0
+        IL_004c:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_0051:  castclass  Match01/Test1/X11
+        IL_0056:  stloc.3
+        IL_0057:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_005c:  stloc.s    V_4
+        IL_005e:  ldloc.2
+        IL_005f:  ldfld      int32 Match01/Test1/X11::item
+        IL_0064:  stloc.s    V_5
+        IL_0066:  ldloc.3
+        IL_0067:  ldfld      int32 Match01/Test1/X11::item
+        IL_006c:  stloc.s    V_6
+        IL_006e:  ldloc.s    V_5
+        IL_0070:  ldloc.s    V_6
+        IL_0072:  cgt
+        IL_0074:  ldloc.s    V_5
+        IL_0076:  ldloc.s    V_6
+        IL_0078:  clt
+        IL_007a:  sub
+        IL_007b:  ret
+
+        IL_007c:  ldarg.0
+        IL_007d:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0082:  castclass  Match01/Test1/X12
+        IL_0087:  stloc.s    V_7
+        IL_0089:  ldarg.0
+        IL_008a:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_008f:  castclass  Match01/Test1/X12
+        IL_0094:  stloc.s    V_8
+        IL_0096:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_009b:  stloc.s    V_4
+        IL_009d:  ldloc.s    V_7
+        IL_009f:  ldfld      int32 Match01/Test1/X12::item
+        IL_00a4:  stloc.s    V_5
+        IL_00a6:  ldloc.s    V_8
+        IL_00a8:  ldfld      int32 Match01/Test1/X12::item
+        IL_00ad:  stloc.s    V_6
+        IL_00af:  ldloc.s    V_5
+        IL_00b1:  ldloc.s    V_6
+        IL_00b3:  cgt
+        IL_00b5:  ldloc.s    V_5
+        IL_00b7:  ldloc.s    V_6
+        IL_00b9:  clt
+        IL_00bb:  sub
+        IL_00bc:  ret
+
+        IL_00bd:  ldarg.0
+        IL_00be:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_00c3:  castclass  Match01/Test1/X13
+        IL_00c8:  stloc.s    V_9
+        IL_00ca:  ldarg.0
+        IL_00cb:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_00d0:  castclass  Match01/Test1/X13
+        IL_00d5:  stloc.s    V_10
+        IL_00d7:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_00dc:  stloc.s    V_4
+        IL_00de:  ldloc.s    V_9
+        IL_00e0:  ldfld      int32 Match01/Test1/X13::item
+        IL_00e5:  stloc.s    V_5
+        IL_00e7:  ldloc.s    V_10
+        IL_00e9:  ldfld      int32 Match01/Test1/X13::item
+        IL_00ee:  stloc.s    V_6
+        IL_00f0:  ldloc.s    V_5
+        IL_00f2:  ldloc.s    V_6
+        IL_00f4:  cgt
+        IL_00f6:  ldloc.s    V_5
+        IL_00f8:  ldloc.s    V_6
+        IL_00fa:  clt
+        IL_00fc:  sub
+        IL_00fd:  ret
+
+        IL_00fe:  ldarg.0
+        IL_00ff:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0104:  castclass  Match01/Test1/X14
+        IL_0109:  stloc.s    V_11
+        IL_010b:  ldarg.0
+        IL_010c:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_0111:  castclass  Match01/Test1/X14
+        IL_0116:  stloc.s    V_12
+        IL_0118:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_011d:  stloc.s    V_4
+        IL_011f:  ldloc.s    V_11
+        IL_0121:  ldfld      int32 Match01/Test1/X14::item
+        IL_0126:  stloc.s    V_5
+        IL_0128:  ldloc.s    V_12
+        IL_012a:  ldfld      int32 Match01/Test1/X14::item
+        IL_012f:  stloc.s    V_6
+        IL_0131:  ldloc.s    V_5
+        IL_0133:  ldloc.s    V_6
+        IL_0135:  cgt
+        IL_0137:  ldloc.s    V_5
+        IL_0139:  ldloc.s    V_6
+        IL_013b:  clt
+        IL_013d:  sub
+        IL_013e:  ret
+
+        IL_013f:  ldloc.0
+        IL_0140:  ldloc.1
+        IL_0141:  sub
+        IL_0142:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'clo@4-1'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>
+    {
+      .field public class Match01/Test1 this
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class Match01/Test1 objTemp
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class Match01/Test1 this,
+                                   class Match01/Test1 objTemp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance int32 Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 int32 V_1,
+                 class Match01/Test1/X11 V_2,
+                 class Match01/Test1/X11 V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class Match01/Test1/X12 V_6,
+                 class Match01/Test1/X12 V_7,
+                 class Match01/Test1/X13 V_8,
+                 class Match01/Test1/X13 V_9,
+                 class Match01/Test1/X14 V_10,
+                 class Match01/Test1/X14 V_11)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_0006:  ldfld      int32 Match01/Test1::_tag
+        IL_000b:  stloc.0
+        IL_000c:  ldarg.0
+        IL_000d:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_0012:  ldfld      int32 Match01/Test1::_tag
+        IL_0017:  stloc.1
+        IL_0018:  ldloc.0
+        IL_0019:  ldloc.1
+        IL_001a:  bne.un     IL_0123
+
+        IL_001f:  ldarg.0
+        IL_0020:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_0025:  call       instance int32 Match01/Test1::get_Tag()
+        IL_002a:  switch     ( 
+                              IL_003f,
+                              IL_0075,
+                              IL_00af,
+                              IL_00e9)
+        IL_003f:  ldarg.0
+        IL_0040:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_0045:  castclass  Match01/Test1/X11
+        IL_004a:  stloc.2
+        IL_004b:  ldarg.0
+        IL_004c:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_0051:  castclass  Match01/Test1/X11
+        IL_0056:  stloc.3
+        IL_0057:  ldloc.2
+        IL_0058:  ldfld      int32 Match01/Test1/X11::item
+        IL_005d:  stloc.s    V_4
+        IL_005f:  ldloc.3
+        IL_0060:  ldfld      int32 Match01/Test1/X11::item
+        IL_0065:  stloc.s    V_5
+        IL_0067:  ldloc.s    V_4
+        IL_0069:  ldloc.s    V_5
+        IL_006b:  cgt
+        IL_006d:  ldloc.s    V_4
+        IL_006f:  ldloc.s    V_5
+        IL_0071:  clt
+        IL_0073:  sub
+        IL_0074:  ret
+
+        IL_0075:  ldarg.0
+        IL_0076:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_007b:  castclass  Match01/Test1/X12
+        IL_0080:  stloc.s    V_6
+        IL_0082:  ldarg.0
+        IL_0083:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_0088:  castclass  Match01/Test1/X12
+        IL_008d:  stloc.s    V_7
+        IL_008f:  ldloc.s    V_6
+        IL_0091:  ldfld      int32 Match01/Test1/X12::item
+        IL_0096:  stloc.s    V_4
+        IL_0098:  ldloc.s    V_7
+        IL_009a:  ldfld      int32 Match01/Test1/X12::item
+        IL_009f:  stloc.s    V_5
+        IL_00a1:  ldloc.s    V_4
+        IL_00a3:  ldloc.s    V_5
+        IL_00a5:  cgt
+        IL_00a7:  ldloc.s    V_4
+        IL_00a9:  ldloc.s    V_5
+        IL_00ab:  clt
+        IL_00ad:  sub
+        IL_00ae:  ret
+
+        IL_00af:  ldarg.0
+        IL_00b0:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_00b5:  castclass  Match01/Test1/X13
+        IL_00ba:  stloc.s    V_8
+        IL_00bc:  ldarg.0
+        IL_00bd:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_00c2:  castclass  Match01/Test1/X13
+        IL_00c7:  stloc.s    V_9
+        IL_00c9:  ldloc.s    V_8
+        IL_00cb:  ldfld      int32 Match01/Test1/X13::item
+        IL_00d0:  stloc.s    V_4
+        IL_00d2:  ldloc.s    V_9
+        IL_00d4:  ldfld      int32 Match01/Test1/X13::item
+        IL_00d9:  stloc.s    V_5
+        IL_00db:  ldloc.s    V_4
+        IL_00dd:  ldloc.s    V_5
+        IL_00df:  cgt
+        IL_00e1:  ldloc.s    V_4
+        IL_00e3:  ldloc.s    V_5
+        IL_00e5:  clt
+        IL_00e7:  sub
+        IL_00e8:  ret
+
+        IL_00e9:  ldarg.0
+        IL_00ea:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_00ef:  castclass  Match01/Test1/X14
+        IL_00f4:  stloc.s    V_10
+        IL_00f6:  ldarg.0
+        IL_00f7:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_00fc:  castclass  Match01/Test1/X14
+        IL_0101:  stloc.s    V_11
+        IL_0103:  ldloc.s    V_10
+        IL_0105:  ldfld      int32 Match01/Test1/X14::item
+        IL_010a:  stloc.s    V_4
+        IL_010c:  ldloc.s    V_11
+        IL_010e:  ldfld      int32 Match01/Test1/X14::item
+        IL_0113:  stloc.s    V_5
+        IL_0115:  ldloc.s    V_4
+        IL_0117:  ldloc.s    V_5
+        IL_0119:  cgt
+        IL_011b:  ldloc.s    V_4
+        IL_011d:  ldloc.s    V_5
+        IL_011f:  clt
+        IL_0121:  sub
+        IL_0122:  ret
+
+        IL_0123:  ldloc.0
+        IL_0124:  ldloc.1
+        IL_0125:  sub
+        IL_0126:  ret
+      } 
+
+    } 
+
+    .field assembly initonly int32 _tag
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(int32 _tag) cil managed
+    {
+      .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                              class [runtime]System.Type) = ( 01 00 E0 07 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                               65 73 74 31 00 00 )                               
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 Match01/Test1::_tag
+      IL_000d:  ret
+    } 
+
+    .method public static class Match01/Test1 NewX11(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void Match01/Test1/X11::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsX11() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public static class Match01/Test1 NewX12(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void Match01/Test1/X12::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsX12() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0006:  ldc.i4.1
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public static class Match01/Test1 NewX13(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 02 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void Match01/Test1/X13::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsX13() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0006:  ldc.i4.2
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public static class Match01/Test1 NewX14(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 03 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void Match01/Test1/X14::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsX14() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0006:  ldc.i4.3
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 Match01/Test1::_tag
+      IL_0006:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class Match01/Test1>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class Match01/Test1 obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001a
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_0018
+
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  newobj     instance void Match01/Test1/clo@4::.ctor(class Match01/Test1,
+                                                                    class Match01/Test1)
+      IL_000d:  stloc.0
+      IL_000e:  ldloc.0
+      IL_000f:  ldnull
+      IL_0010:  tail.
+      IL_0012:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::Invoke(!0)
+      IL_0017:  ret
+
+      IL_0018:  ldc.i4.1
+      IL_0019:  ret
+
+      IL_001a:  ldarg.1
+      IL_001b:  brfalse.s  IL_001f
+
+      IL_001d:  ldc.i4.m1
+      IL_001e:  ret
+
+      IL_001f:  ldc.i4.0
+      IL_0020:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  Match01/Test1
+      IL_0007:  callvirt   instance int32 Match01/Test1::CompareTo(class Match01/Test1)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class Match01/Test1 V_0,
+               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  Match01/Test1
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_0026
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  Match01/Test1
+      IL_0010:  brfalse.s  IL_0024
+
+      IL_0012:  ldarg.0
+      IL_0013:  ldloc.0
+      IL_0014:  newobj     instance void Match01/Test1/'clo@4-1'::.ctor(class Match01/Test1,
+                                                                        class Match01/Test1)
+      IL_0019:  stloc.1
+      IL_001a:  ldloc.1
+      IL_001b:  ldnull
+      IL_001c:  tail.
+      IL_001e:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::Invoke(!0)
+      IL_0023:  ret
+
+      IL_0024:  ldc.i4.1
+      IL_0025:  ret
+
+      IL_0026:  ldarg.1
+      IL_0027:  unbox.any  Match01/Test1
+      IL_002c:  brfalse.s  IL_0030
+
+      IL_002e:  ldc.i4.m1
+      IL_002f:  ret
+
+      IL_0030:  ldc.i4.0
+      IL_0031:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class Match01/Test1/X11 V_1,
+               class Match01/Test1/X12 V_2,
+               class Match01/Test1/X13 V_3,
+               class Match01/Test1/X14 V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse    IL_00a5
+
+      IL_0006:  ldc.i4.0
+      IL_0007:  stloc.0
+      IL_0008:  ldarg.0
+      IL_0009:  call       instance int32 Match01/Test1::get_Tag()
+      IL_000e:  switch     ( 
+                            IL_0023,
+                            IL_0043,
+                            IL_0063,
+                            IL_0083)
+      IL_0023:  ldarg.0
+      IL_0024:  castclass  Match01/Test1/X11
+      IL_0029:  stloc.1
+      IL_002a:  ldc.i4.0
+      IL_002b:  stloc.0
+      IL_002c:  ldc.i4     0x9e3779b9
+      IL_0031:  ldloc.1
+      IL_0032:  ldfld      int32 Match01/Test1/X11::item
+      IL_0037:  ldloc.0
+      IL_0038:  ldc.i4.6
+      IL_0039:  shl
+      IL_003a:  ldloc.0
+      IL_003b:  ldc.i4.2
+      IL_003c:  shr
+      IL_003d:  add
+      IL_003e:  add
+      IL_003f:  add
+      IL_0040:  stloc.0
+      IL_0041:  ldloc.0
+      IL_0042:  ret
+
+      IL_0043:  ldarg.0
+      IL_0044:  castclass  Match01/Test1/X12
+      IL_0049:  stloc.2
+      IL_004a:  ldc.i4.1
+      IL_004b:  stloc.0
+      IL_004c:  ldc.i4     0x9e3779b9
+      IL_0051:  ldloc.2
+      IL_0052:  ldfld      int32 Match01/Test1/X12::item
+      IL_0057:  ldloc.0
+      IL_0058:  ldc.i4.6
+      IL_0059:  shl
+      IL_005a:  ldloc.0
+      IL_005b:  ldc.i4.2
+      IL_005c:  shr
+      IL_005d:  add
+      IL_005e:  add
+      IL_005f:  add
+      IL_0060:  stloc.0
+      IL_0061:  ldloc.0
+      IL_0062:  ret
+
+      IL_0063:  ldarg.0
+      IL_0064:  castclass  Match01/Test1/X13
+      IL_0069:  stloc.3
+      IL_006a:  ldc.i4.2
+      IL_006b:  stloc.0
+      IL_006c:  ldc.i4     0x9e3779b9
+      IL_0071:  ldloc.3
+      IL_0072:  ldfld      int32 Match01/Test1/X13::item
+      IL_0077:  ldloc.0
+      IL_0078:  ldc.i4.6
+      IL_0079:  shl
+      IL_007a:  ldloc.0
+      IL_007b:  ldc.i4.2
+      IL_007c:  shr
+      IL_007d:  add
+      IL_007e:  add
+      IL_007f:  add
+      IL_0080:  stloc.0
+      IL_0081:  ldloc.0
+      IL_0082:  ret
+
+      IL_0083:  ldarg.0
+      IL_0084:  castclass  Match01/Test1/X14
+      IL_0089:  stloc.s    V_4
+      IL_008b:  ldc.i4.3
+      IL_008c:  stloc.0
+      IL_008d:  ldc.i4     0x9e3779b9
+      IL_0092:  ldloc.s    V_4
+      IL_0094:  ldfld      int32 Match01/Test1/X14::item
+      IL_0099:  ldloc.0
+      IL_009a:  ldc.i4.6
+      IL_009b:  shl
+      IL_009c:  ldloc.0
+      IL_009d:  ldc.i4.2
+      IL_009e:  shr
+      IL_009f:  add
+      IL_00a0:  add
+      IL_00a1:  add
+      IL_00a2:  stloc.0
+      IL_00a3:  ldloc.0
+      IL_00a4:  ret
+
+      IL_00a5:  ldc.i4.0
+      IL_00a6:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 Match01/Test1::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class Match01/Test1 V_0,
+               int32 V_1,
+               int32 V_2,
+               class Match01/Test1/X11 V_3,
+               class Match01/Test1/X11 V_4,
+               class Match01/Test1/X12 V_5,
+               class Match01/Test1/X12 V_6,
+               class Match01/Test1/X13 V_7,
+               class Match01/Test1/X13 V_8,
+               class Match01/Test1/X14 V_9,
+               class Match01/Test1/X14 V_10)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse    IL_00c9
+
+      IL_0006:  ldarg.1
+      IL_0007:  isinst     Match01/Test1
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  brfalse    IL_00c7
+
+      IL_0013:  ldarg.0
+      IL_0014:  ldfld      int32 Match01/Test1::_tag
+      IL_0019:  stloc.1
+      IL_001a:  ldloc.0
+      IL_001b:  ldfld      int32 Match01/Test1::_tag
+      IL_0020:  stloc.2
+      IL_0021:  ldloc.1
+      IL_0022:  ldloc.2
+      IL_0023:  bne.un     IL_00c5
+
+      IL_0028:  ldarg.0
+      IL_0029:  call       instance int32 Match01/Test1::get_Tag()
+      IL_002e:  switch     ( 
+                            IL_0043,
+                            IL_0062,
+                            IL_0083,
+                            IL_00a4)
+      IL_0043:  ldarg.0
+      IL_0044:  castclass  Match01/Test1/X11
+      IL_0049:  stloc.3
+      IL_004a:  ldloc.0
+      IL_004b:  castclass  Match01/Test1/X11
+      IL_0050:  stloc.s    V_4
+      IL_0052:  ldloc.3
+      IL_0053:  ldfld      int32 Match01/Test1/X11::item
+      IL_0058:  ldloc.s    V_4
+      IL_005a:  ldfld      int32 Match01/Test1/X11::item
+      IL_005f:  ceq
+      IL_0061:  ret
+
+      IL_0062:  ldarg.0
+      IL_0063:  castclass  Match01/Test1/X12
+      IL_0068:  stloc.s    V_5
+      IL_006a:  ldloc.0
+      IL_006b:  castclass  Match01/Test1/X12
+      IL_0070:  stloc.s    V_6
+      IL_0072:  ldloc.s    V_5
+      IL_0074:  ldfld      int32 Match01/Test1/X12::item
+      IL_0079:  ldloc.s    V_6
+      IL_007b:  ldfld      int32 Match01/Test1/X12::item
+      IL_0080:  ceq
+      IL_0082:  ret
+
+      IL_0083:  ldarg.0
+      IL_0084:  castclass  Match01/Test1/X13
+      IL_0089:  stloc.s    V_7
+      IL_008b:  ldloc.0
+      IL_008c:  castclass  Match01/Test1/X13
+      IL_0091:  stloc.s    V_8
+      IL_0093:  ldloc.s    V_7
+      IL_0095:  ldfld      int32 Match01/Test1/X13::item
+      IL_009a:  ldloc.s    V_8
+      IL_009c:  ldfld      int32 Match01/Test1/X13::item
+      IL_00a1:  ceq
+      IL_00a3:  ret
+
+      IL_00a4:  ldarg.0
+      IL_00a5:  castclass  Match01/Test1/X14
+      IL_00aa:  stloc.s    V_9
+      IL_00ac:  ldloc.0
+      IL_00ad:  castclass  Match01/Test1/X14
+      IL_00b2:  stloc.s    V_10
+      IL_00b4:  ldloc.s    V_9
+      IL_00b6:  ldfld      int32 Match01/Test1/X14::item
+      IL_00bb:  ldloc.s    V_10
+      IL_00bd:  ldfld      int32 Match01/Test1/X14::item
+      IL_00c2:  ceq
+      IL_00c4:  ret
+
+      IL_00c5:  ldc.i4.0
+      IL_00c6:  ret
+
+      IL_00c7:  ldc.i4.0
+      IL_00c8:  ret
+
+      IL_00c9:  ldarg.1
+      IL_00ca:  ldnull
+      IL_00cb:  cgt.un
+      IL_00cd:  ldc.i4.0
+      IL_00ce:  ceq
+      IL_00d0:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class Match01/Test1 obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (int32 V_0,
+               int32 V_1,
+               class Match01/Test1/X11 V_2,
+               class Match01/Test1/X11 V_3,
+               class Match01/Test1/X12 V_4,
+               class Match01/Test1/X12 V_5,
+               class Match01/Test1/X13 V_6,
+               class Match01/Test1/X13 V_7,
+               class Match01/Test1/X14 V_8,
+               class Match01/Test1/X14 V_9)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse    IL_00c0
+
+      IL_0006:  ldarg.1
+      IL_0007:  brfalse    IL_00be
+
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      int32 Match01/Test1::_tag
+      IL_0012:  stloc.0
+      IL_0013:  ldarg.1
+      IL_0014:  ldfld      int32 Match01/Test1::_tag
+      IL_0019:  stloc.1
+      IL_001a:  ldloc.0
+      IL_001b:  ldloc.1
+      IL_001c:  bne.un     IL_00bc
+
+      IL_0021:  ldarg.0
+      IL_0022:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0027:  switch     ( 
+                            IL_003c,
+                            IL_0059,
+                            IL_007a,
+                            IL_009b)
+      IL_003c:  ldarg.0
+      IL_003d:  castclass  Match01/Test1/X11
+      IL_0042:  stloc.2
+      IL_0043:  ldarg.1
+      IL_0044:  castclass  Match01/Test1/X11
+      IL_0049:  stloc.3
+      IL_004a:  ldloc.2
+      IL_004b:  ldfld      int32 Match01/Test1/X11::item
+      IL_0050:  ldloc.3
+      IL_0051:  ldfld      int32 Match01/Test1/X11::item
+      IL_0056:  ceq
+      IL_0058:  ret
+
+      IL_0059:  ldarg.0
+      IL_005a:  castclass  Match01/Test1/X12
+      IL_005f:  stloc.s    V_4
+      IL_0061:  ldarg.1
+      IL_0062:  castclass  Match01/Test1/X12
+      IL_0067:  stloc.s    V_5
+      IL_0069:  ldloc.s    V_4
+      IL_006b:  ldfld      int32 Match01/Test1/X12::item
+      IL_0070:  ldloc.s    V_5
+      IL_0072:  ldfld      int32 Match01/Test1/X12::item
+      IL_0077:  ceq
+      IL_0079:  ret
+
+      IL_007a:  ldarg.0
+      IL_007b:  castclass  Match01/Test1/X13
+      IL_0080:  stloc.s    V_6
+      IL_0082:  ldarg.1
+      IL_0083:  castclass  Match01/Test1/X13
+      IL_0088:  stloc.s    V_7
+      IL_008a:  ldloc.s    V_6
+      IL_008c:  ldfld      int32 Match01/Test1/X13::item
+      IL_0091:  ldloc.s    V_7
+      IL_0093:  ldfld      int32 Match01/Test1/X13::item
+      IL_0098:  ceq
+      IL_009a:  ret
+
+      IL_009b:  ldarg.0
+      IL_009c:  castclass  Match01/Test1/X14
+      IL_00a1:  stloc.s    V_8
+      IL_00a3:  ldarg.1
+      IL_00a4:  castclass  Match01/Test1/X14
+      IL_00a9:  stloc.s    V_9
+      IL_00ab:  ldloc.s    V_8
+      IL_00ad:  ldfld      int32 Match01/Test1/X14::item
+      IL_00b2:  ldloc.s    V_9
+      IL_00b4:  ldfld      int32 Match01/Test1/X14::item
+      IL_00b9:  ceq
+      IL_00bb:  ret
+
+      IL_00bc:  ldc.i4.0
+      IL_00bd:  ret
+
+      IL_00be:  ldc.i4.0
+      IL_00bf:  ret
+
+      IL_00c0:  ldarg.1
+      IL_00c1:  ldnull
+      IL_00c2:  cgt.un
+      IL_00c4:  ldc.i4.0
+      IL_00c5:  ceq
+      IL_00c7:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class Match01/Test1 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     Match01/Test1
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool Match01/Test1::Equals(class Match01/Test1)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 Match01/Test1::get_Tag()
+    } 
+    .property instance bool IsX11()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool Match01/Test1::get_IsX11()
+    } 
+    .property instance bool IsX12()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool Match01/Test1::get_IsX12()
+    } 
+    .property instance bool IsX13()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool Match01/Test1::get_IsX13()
+    } 
+    .property instance bool IsX14()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool Match01/Test1::get_IsX14()
+    } 
+  } 
+
+  .method public static int32  select1(class Match01/Test1 x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ldarg.0
+    IL_0002:  call       instance int32 Match01/Test1::get_Tag()
+    IL_0007:  switch     ( 
+                          IL_001c,
+                          IL_0028,
+                          IL_002a,
+                          IL_002c)
+    IL_001c:  ldarg.0
+    IL_001d:  castclass  Match01/Test1/X11
+    IL_0022:  ldfld      int32 Match01/Test1/X11::item
+    IL_0027:  ret
+
+    IL_0028:  ldc.i4.2
+    IL_0029:  ret
+
+    IL_002a:  ldc.i4.3
+    IL_002b:  ret
+
+    IL_002c:  ldc.i4.4
+    IL_002d:  ret
+  } 
+
+  .method public static int32  fm(class Match01/Test1 y) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       int32 Match01::select1(class Match01/Test1)
+    IL_0006:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Match01
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+.class private auto ansi serializable sealed System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+       extends [runtime]System.Enum
+{
+  .custom instance void [runtime]System.FlagsAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field public specialname rtspecialname int32 value__
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes All = int32(0xFFFFFFFF)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes None = int32(0x00000000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicParameterlessConstructor = int32(0x00000001)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicConstructors = int32(0x00000003)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicConstructors = int32(0x00000004)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicMethods = int32(0x00000008)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicMethods = int32(0x00000010)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicFields = int32(0x00000020)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicFields = int32(0x00000040)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicNestedTypes = int32(0x00000080)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicNestedTypes = int32(0x00000100)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicProperties = int32(0x00000200)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicProperties = int32(0x00000400)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicEvents = int32(0x00000800)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicEvents = int32(0x00001000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes Interfaces = int32(0x00002000)
+} 
+
+.class private auto ansi beforefieldinit System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute
+       extends [runtime]System.Attribute
+{
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private class [runtime]System.Type Type@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public specialname rtspecialname 
+          instance void  .ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType,
+                               class [runtime]System.Type Type) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Attribute::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_000d:  ldarg.0
+    IL_000e:  ldarg.2
+    IL_000f:  stfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0014:  ret
+  } 
+
+  .method public hidebysig specialname instance class [runtime]System.Type get_Type() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes get_MemberType() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_0006:  ret
+  } 
+
+  .property instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+          MemberType()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_MemberType()
+  } 
+  .property instance class [runtime]System.Type
+          Type()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_Type()
+  } 
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOn.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOn.fs.il.net472.release.bsl
new file mode 100644
index 00000000000..8d01ee81962
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOn.fs.il.net472.release.bsl
@@ -0,0 +1,1601 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Match01
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto autochar serializable nested public beforefieldinit Test1
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class Match01/Test1>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class Match01/Test1>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                   61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .class abstract auto ansi sealed nested public Tags
+           extends [runtime]System.Object
+    {
+      .field public static literal int32 X11 = int32(0x00000000)
+      .field public static literal int32 X12 = int32(0x00000001)
+      .field public static literal int32 X13 = int32(0x00000002)
+      .field public static literal int32 X14 = int32(0x00000003)
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit specialname X11
+           extends Match01/Test1
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
+                                                                                                                            2B 58 31 31 40 44 65 62 75 67 54 79 70 65 50 72   
+                                                                                                                            6F 78 79 00 00 )                                  
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                     61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                 65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.0
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.1
+        IL_0009:  stfld      int32 Match01/Test1/X11::item
+        IL_000e:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 Match01/Test1/X11::item
+        IL_0006:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X11::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit specialname X12
+           extends Match01/Test1
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
+                                                                                                                            2B 58 31 32 40 44 65 62 75 67 54 79 70 65 50 72   
+                                                                                                                            6F 78 79 00 00 )                                  
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                     61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                 65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.1
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.1
+        IL_0009:  stfld      int32 Match01/Test1/X12::item
+        IL_000e:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 Match01/Test1/X12::item
+        IL_0006:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 01 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X12::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit specialname X13
+           extends Match01/Test1
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
+                                                                                                                            2B 58 31 33 40 44 65 62 75 67 54 79 70 65 50 72   
+                                                                                                                            6F 78 79 00 00 )                                  
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                     61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                 65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.2
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.1
+        IL_0009:  stfld      int32 Match01/Test1/X13::item
+        IL_000e:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 Match01/Test1/X13::item
+        IL_0006:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 02 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X13::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit specialname X14
+           extends Match01/Test1
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
+                                                                                                                            2B 58 31 34 40 44 65 62 75 67 54 79 70 65 50 72   
+                                                                                                                            6F 78 79 00 00 )                                  
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                     61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                 65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.3
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.1
+        IL_0009:  stfld      int32 Match01/Test1/X14::item
+        IL_000e:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 Match01/Test1/X14::item
+        IL_0006:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 03 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X14::get_Item()
+      } 
+    } 
+
+    .class auto ansi nested assembly beforefieldinit specialname X11@DebugTypeProxy
+           extends [runtime]System.Object
+    {
+      .field assembly class Match01/Test1/X11 _obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X11 obj) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                 65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1/X11 Match01/Test1/X11@DebugTypeProxy::_obj
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1/X11 Match01/Test1/X11@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X11::item
+        IL_000b:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X11@DebugTypeProxy::get_Item()
+      } 
+    } 
+
+    .class auto ansi nested assembly beforefieldinit specialname X12@DebugTypeProxy
+           extends [runtime]System.Object
+    {
+      .field assembly class Match01/Test1/X12 _obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X12 obj) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                 65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1/X12 Match01/Test1/X12@DebugTypeProxy::_obj
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1/X12 Match01/Test1/X12@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X12::item
+        IL_000b:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 01 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X12@DebugTypeProxy::get_Item()
+      } 
+    } 
+
+    .class auto ansi nested assembly beforefieldinit specialname X13@DebugTypeProxy
+           extends [runtime]System.Object
+    {
+      .field assembly class Match01/Test1/X13 _obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X13 obj) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                 65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1/X13 Match01/Test1/X13@DebugTypeProxy::_obj
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1/X13 Match01/Test1/X13@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X13::item
+        IL_000b:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 02 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X13@DebugTypeProxy::get_Item()
+      } 
+    } 
+
+    .class auto ansi nested assembly beforefieldinit specialname X14@DebugTypeProxy
+           extends [runtime]System.Object
+    {
+      .field assembly class Match01/Test1/X14 _obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X14 obj) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                 65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1/X14 Match01/Test1/X14@DebugTypeProxy::_obj
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1/X14 Match01/Test1/X14@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X14::item
+        IL_000b:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 03 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X14@DebugTypeProxy::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit clo@4
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>
+    {
+      .field public class Match01/Test1 this
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class Match01/Test1 obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class Match01/Test1 this,
+                                   class Match01/Test1 obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance int32 Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 int32 V_1,
+                 class Match01/Test1/X11 V_2,
+                 class Match01/Test1/X11 V_3,
+                 class [runtime]System.Collections.IComparer V_4,
+                 int32 V_5,
+                 int32 V_6,
+                 class Match01/Test1/X12 V_7,
+                 class Match01/Test1/X12 V_8,
+                 class Match01/Test1/X13 V_9,
+                 class Match01/Test1/X13 V_10,
+                 class Match01/Test1/X14 V_11,
+                 class Match01/Test1/X14 V_12)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0006:  ldfld      int32 Match01/Test1::_tag
+        IL_000b:  stloc.0
+        IL_000c:  ldarg.0
+        IL_000d:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_0012:  ldfld      int32 Match01/Test1::_tag
+        IL_0017:  stloc.1
+        IL_0018:  ldloc.0
+        IL_0019:  ldloc.1
+        IL_001a:  bne.un     IL_013f
+
+        IL_001f:  ldarg.0
+        IL_0020:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0025:  call       instance int32 Match01/Test1::get_Tag()
+        IL_002a:  switch     ( 
+                              IL_003f,
+                              IL_007c,
+                              IL_00bd,
+                              IL_00fe)
+        IL_003f:  ldarg.0
+        IL_0040:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0045:  castclass  Match01/Test1/X11
+        IL_004a:  stloc.2
+        IL_004b:  ldarg.0
+        IL_004c:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_0051:  castclass  Match01/Test1/X11
+        IL_0056:  stloc.3
+        IL_0057:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_005c:  stloc.s    V_4
+        IL_005e:  ldloc.2
+        IL_005f:  ldfld      int32 Match01/Test1/X11::item
+        IL_0064:  stloc.s    V_5
+        IL_0066:  ldloc.3
+        IL_0067:  ldfld      int32 Match01/Test1/X11::item
+        IL_006c:  stloc.s    V_6
+        IL_006e:  ldloc.s    V_5
+        IL_0070:  ldloc.s    V_6
+        IL_0072:  cgt
+        IL_0074:  ldloc.s    V_5
+        IL_0076:  ldloc.s    V_6
+        IL_0078:  clt
+        IL_007a:  sub
+        IL_007b:  ret
+
+        IL_007c:  ldarg.0
+        IL_007d:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0082:  castclass  Match01/Test1/X12
+        IL_0087:  stloc.s    V_7
+        IL_0089:  ldarg.0
+        IL_008a:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_008f:  castclass  Match01/Test1/X12
+        IL_0094:  stloc.s    V_8
+        IL_0096:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_009b:  stloc.s    V_4
+        IL_009d:  ldloc.s    V_7
+        IL_009f:  ldfld      int32 Match01/Test1/X12::item
+        IL_00a4:  stloc.s    V_5
+        IL_00a6:  ldloc.s    V_8
+        IL_00a8:  ldfld      int32 Match01/Test1/X12::item
+        IL_00ad:  stloc.s    V_6
+        IL_00af:  ldloc.s    V_5
+        IL_00b1:  ldloc.s    V_6
+        IL_00b3:  cgt
+        IL_00b5:  ldloc.s    V_5
+        IL_00b7:  ldloc.s    V_6
+        IL_00b9:  clt
+        IL_00bb:  sub
+        IL_00bc:  ret
+
+        IL_00bd:  ldarg.0
+        IL_00be:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_00c3:  castclass  Match01/Test1/X13
+        IL_00c8:  stloc.s    V_9
+        IL_00ca:  ldarg.0
+        IL_00cb:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_00d0:  castclass  Match01/Test1/X13
+        IL_00d5:  stloc.s    V_10
+        IL_00d7:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_00dc:  stloc.s    V_4
+        IL_00de:  ldloc.s    V_9
+        IL_00e0:  ldfld      int32 Match01/Test1/X13::item
+        IL_00e5:  stloc.s    V_5
+        IL_00e7:  ldloc.s    V_10
+        IL_00e9:  ldfld      int32 Match01/Test1/X13::item
+        IL_00ee:  stloc.s    V_6
+        IL_00f0:  ldloc.s    V_5
+        IL_00f2:  ldloc.s    V_6
+        IL_00f4:  cgt
+        IL_00f6:  ldloc.s    V_5
+        IL_00f8:  ldloc.s    V_6
+        IL_00fa:  clt
+        IL_00fc:  sub
+        IL_00fd:  ret
+
+        IL_00fe:  ldarg.0
+        IL_00ff:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0104:  castclass  Match01/Test1/X14
+        IL_0109:  stloc.s    V_11
+        IL_010b:  ldarg.0
+        IL_010c:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_0111:  castclass  Match01/Test1/X14
+        IL_0116:  stloc.s    V_12
+        IL_0118:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_011d:  stloc.s    V_4
+        IL_011f:  ldloc.s    V_11
+        IL_0121:  ldfld      int32 Match01/Test1/X14::item
+        IL_0126:  stloc.s    V_5
+        IL_0128:  ldloc.s    V_12
+        IL_012a:  ldfld      int32 Match01/Test1/X14::item
+        IL_012f:  stloc.s    V_6
+        IL_0131:  ldloc.s    V_5
+        IL_0133:  ldloc.s    V_6
+        IL_0135:  cgt
+        IL_0137:  ldloc.s    V_5
+        IL_0139:  ldloc.s    V_6
+        IL_013b:  clt
+        IL_013d:  sub
+        IL_013e:  ret
+
+        IL_013f:  ldloc.0
+        IL_0140:  ldloc.1
+        IL_0141:  sub
+        IL_0142:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'clo@4-1'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>
+    {
+      .field public class Match01/Test1 this
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public object obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class Match01/Test1 objTemp
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class Match01/Test1 this,
+                                   object obj,
+                                   class Match01/Test1 objTemp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      object Match01/Test1/'clo@4-1'::obj
+        IL_0014:  ldarg.0
+        IL_0015:  ldarg.3
+        IL_0016:  stfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_001b:  ret
+      } 
+
+      .method public strict virtual instance int32 Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 int32 V_1,
+                 class Match01/Test1/X11 V_2,
+                 class Match01/Test1/X11 V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class Match01/Test1/X12 V_6,
+                 class Match01/Test1/X12 V_7,
+                 class Match01/Test1/X13 V_8,
+                 class Match01/Test1/X13 V_9,
+                 class Match01/Test1/X14 V_10,
+                 class Match01/Test1/X14 V_11)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      object Match01/Test1/'clo@4-1'::obj
+        IL_0006:  unbox.any  Match01/Test1
+        IL_000b:  brfalse    IL_0137
+
+        IL_0010:  ldarg.0
+        IL_0011:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_0016:  ldfld      int32 Match01/Test1::_tag
+        IL_001b:  stloc.0
+        IL_001c:  ldarg.0
+        IL_001d:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_0022:  ldfld      int32 Match01/Test1::_tag
+        IL_0027:  stloc.1
+        IL_0028:  ldloc.0
+        IL_0029:  ldloc.1
+        IL_002a:  bne.un     IL_0133
+
+        IL_002f:  ldarg.0
+        IL_0030:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_0035:  call       instance int32 Match01/Test1::get_Tag()
+        IL_003a:  switch     ( 
+                              IL_004f,
+                              IL_0085,
+                              IL_00bf,
+                              IL_00f9)
+        IL_004f:  ldarg.0
+        IL_0050:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_0055:  castclass  Match01/Test1/X11
+        IL_005a:  stloc.2
+        IL_005b:  ldarg.0
+        IL_005c:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_0061:  castclass  Match01/Test1/X11
+        IL_0066:  stloc.3
+        IL_0067:  ldloc.2
+        IL_0068:  ldfld      int32 Match01/Test1/X11::item
+        IL_006d:  stloc.s    V_4
+        IL_006f:  ldloc.3
+        IL_0070:  ldfld      int32 Match01/Test1/X11::item
+        IL_0075:  stloc.s    V_5
+        IL_0077:  ldloc.s    V_4
+        IL_0079:  ldloc.s    V_5
+        IL_007b:  cgt
+        IL_007d:  ldloc.s    V_4
+        IL_007f:  ldloc.s    V_5
+        IL_0081:  clt
+        IL_0083:  sub
+        IL_0084:  ret
+
+        IL_0085:  ldarg.0
+        IL_0086:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_008b:  castclass  Match01/Test1/X12
+        IL_0090:  stloc.s    V_6
+        IL_0092:  ldarg.0
+        IL_0093:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_0098:  castclass  Match01/Test1/X12
+        IL_009d:  stloc.s    V_7
+        IL_009f:  ldloc.s    V_6
+        IL_00a1:  ldfld      int32 Match01/Test1/X12::item
+        IL_00a6:  stloc.s    V_4
+        IL_00a8:  ldloc.s    V_7
+        IL_00aa:  ldfld      int32 Match01/Test1/X12::item
+        IL_00af:  stloc.s    V_5
+        IL_00b1:  ldloc.s    V_4
+        IL_00b3:  ldloc.s    V_5
+        IL_00b5:  cgt
+        IL_00b7:  ldloc.s    V_4
+        IL_00b9:  ldloc.s    V_5
+        IL_00bb:  clt
+        IL_00bd:  sub
+        IL_00be:  ret
+
+        IL_00bf:  ldarg.0
+        IL_00c0:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_00c5:  castclass  Match01/Test1/X13
+        IL_00ca:  stloc.s    V_8
+        IL_00cc:  ldarg.0
+        IL_00cd:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_00d2:  castclass  Match01/Test1/X13
+        IL_00d7:  stloc.s    V_9
+        IL_00d9:  ldloc.s    V_8
+        IL_00db:  ldfld      int32 Match01/Test1/X13::item
+        IL_00e0:  stloc.s    V_4
+        IL_00e2:  ldloc.s    V_9
+        IL_00e4:  ldfld      int32 Match01/Test1/X13::item
+        IL_00e9:  stloc.s    V_5
+        IL_00eb:  ldloc.s    V_4
+        IL_00ed:  ldloc.s    V_5
+        IL_00ef:  cgt
+        IL_00f1:  ldloc.s    V_4
+        IL_00f3:  ldloc.s    V_5
+        IL_00f5:  clt
+        IL_00f7:  sub
+        IL_00f8:  ret
+
+        IL_00f9:  ldarg.0
+        IL_00fa:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_00ff:  castclass  Match01/Test1/X14
+        IL_0104:  stloc.s    V_10
+        IL_0106:  ldarg.0
+        IL_0107:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_010c:  castclass  Match01/Test1/X14
+        IL_0111:  stloc.s    V_11
+        IL_0113:  ldloc.s    V_10
+        IL_0115:  ldfld      int32 Match01/Test1/X14::item
+        IL_011a:  stloc.s    V_4
+        IL_011c:  ldloc.s    V_11
+        IL_011e:  ldfld      int32 Match01/Test1/X14::item
+        IL_0123:  stloc.s    V_5
+        IL_0125:  ldloc.s    V_4
+        IL_0127:  ldloc.s    V_5
+        IL_0129:  cgt
+        IL_012b:  ldloc.s    V_4
+        IL_012d:  ldloc.s    V_5
+        IL_012f:  clt
+        IL_0131:  sub
+        IL_0132:  ret
+
+        IL_0133:  ldloc.0
+        IL_0134:  ldloc.1
+        IL_0135:  sub
+        IL_0136:  ret
+
+        IL_0137:  ldc.i4.1
+        IL_0138:  ret
+      } 
+
+    } 
+
+    .field assembly initonly int32 _tag
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(int32 _tag) cil managed
+    {
+      .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                              class [runtime]System.Type) = ( 01 00 E0 07 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                               65 73 74 31 00 00 )                               
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 Match01/Test1::_tag
+      IL_000d:  ret
+    } 
+
+    .method public static class Match01/Test1 NewX11(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void Match01/Test1/X11::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsX11() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public static class Match01/Test1 NewX12(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void Match01/Test1/X12::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsX12() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0006:  ldc.i4.1
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public static class Match01/Test1 NewX13(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 02 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void Match01/Test1/X13::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsX13() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0006:  ldc.i4.2
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public static class Match01/Test1 NewX14(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 03 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void Match01/Test1/X14::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsX14() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0006:  ldc.i4.3
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 Match01/Test1::_tag
+      IL_0006:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class Match01/Test1>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class Match01/Test1 obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001a
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_0018
+
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  newobj     instance void Match01/Test1/clo@4::.ctor(class Match01/Test1,
+                                                                    class Match01/Test1)
+      IL_000d:  stloc.0
+      IL_000e:  ldloc.0
+      IL_000f:  ldnull
+      IL_0010:  tail.
+      IL_0012:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::Invoke(!0)
+      IL_0017:  ret
+
+      IL_0018:  ldc.i4.1
+      IL_0019:  ret
+
+      IL_001a:  ldarg.1
+      IL_001b:  brfalse.s  IL_001f
+
+      IL_001d:  ldc.i4.m1
+      IL_001e:  ret
+
+      IL_001f:  ldc.i4.0
+      IL_0020:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  Match01/Test1
+      IL_0007:  callvirt   instance int32 Match01/Test1::CompareTo(class Match01/Test1)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class Match01/Test1 V_0,
+               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  Match01/Test1
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_001d
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldarg.1
+      IL_000c:  ldloc.0
+      IL_000d:  newobj     instance void Match01/Test1/'clo@4-1'::.ctor(class Match01/Test1,
+                                                                        object,
+                                                                        class Match01/Test1)
+      IL_0012:  stloc.1
+      IL_0013:  ldloc.1
+      IL_0014:  ldnull
+      IL_0015:  tail.
+      IL_0017:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::Invoke(!0)
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  unbox.any  Match01/Test1
+      IL_0023:  brfalse.s  IL_0027
+
+      IL_0025:  ldc.i4.m1
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class Match01/Test1/X11 V_1,
+               class Match01/Test1/X12 V_2,
+               class Match01/Test1/X13 V_3,
+               class Match01/Test1/X14 V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse    IL_00a5
+
+      IL_0006:  ldc.i4.0
+      IL_0007:  stloc.0
+      IL_0008:  ldarg.0
+      IL_0009:  call       instance int32 Match01/Test1::get_Tag()
+      IL_000e:  switch     ( 
+                            IL_0023,
+                            IL_0043,
+                            IL_0063,
+                            IL_0083)
+      IL_0023:  ldarg.0
+      IL_0024:  castclass  Match01/Test1/X11
+      IL_0029:  stloc.1
+      IL_002a:  ldc.i4.0
+      IL_002b:  stloc.0
+      IL_002c:  ldc.i4     0x9e3779b9
+      IL_0031:  ldloc.1
+      IL_0032:  ldfld      int32 Match01/Test1/X11::item
+      IL_0037:  ldloc.0
+      IL_0038:  ldc.i4.6
+      IL_0039:  shl
+      IL_003a:  ldloc.0
+      IL_003b:  ldc.i4.2
+      IL_003c:  shr
+      IL_003d:  add
+      IL_003e:  add
+      IL_003f:  add
+      IL_0040:  stloc.0
+      IL_0041:  ldloc.0
+      IL_0042:  ret
+
+      IL_0043:  ldarg.0
+      IL_0044:  castclass  Match01/Test1/X12
+      IL_0049:  stloc.2
+      IL_004a:  ldc.i4.1
+      IL_004b:  stloc.0
+      IL_004c:  ldc.i4     0x9e3779b9
+      IL_0051:  ldloc.2
+      IL_0052:  ldfld      int32 Match01/Test1/X12::item
+      IL_0057:  ldloc.0
+      IL_0058:  ldc.i4.6
+      IL_0059:  shl
+      IL_005a:  ldloc.0
+      IL_005b:  ldc.i4.2
+      IL_005c:  shr
+      IL_005d:  add
+      IL_005e:  add
+      IL_005f:  add
+      IL_0060:  stloc.0
+      IL_0061:  ldloc.0
+      IL_0062:  ret
+
+      IL_0063:  ldarg.0
+      IL_0064:  castclass  Match01/Test1/X13
+      IL_0069:  stloc.3
+      IL_006a:  ldc.i4.2
+      IL_006b:  stloc.0
+      IL_006c:  ldc.i4     0x9e3779b9
+      IL_0071:  ldloc.3
+      IL_0072:  ldfld      int32 Match01/Test1/X13::item
+      IL_0077:  ldloc.0
+      IL_0078:  ldc.i4.6
+      IL_0079:  shl
+      IL_007a:  ldloc.0
+      IL_007b:  ldc.i4.2
+      IL_007c:  shr
+      IL_007d:  add
+      IL_007e:  add
+      IL_007f:  add
+      IL_0080:  stloc.0
+      IL_0081:  ldloc.0
+      IL_0082:  ret
+
+      IL_0083:  ldarg.0
+      IL_0084:  castclass  Match01/Test1/X14
+      IL_0089:  stloc.s    V_4
+      IL_008b:  ldc.i4.3
+      IL_008c:  stloc.0
+      IL_008d:  ldc.i4     0x9e3779b9
+      IL_0092:  ldloc.s    V_4
+      IL_0094:  ldfld      int32 Match01/Test1/X14::item
+      IL_0099:  ldloc.0
+      IL_009a:  ldc.i4.6
+      IL_009b:  shl
+      IL_009c:  ldloc.0
+      IL_009d:  ldc.i4.2
+      IL_009e:  shr
+      IL_009f:  add
+      IL_00a0:  add
+      IL_00a1:  add
+      IL_00a2:  stloc.0
+      IL_00a3:  ldloc.0
+      IL_00a4:  ret
+
+      IL_00a5:  ldc.i4.0
+      IL_00a6:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 Match01/Test1::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class Match01/Test1 V_0,
+               int32 V_1,
+               int32 V_2,
+               class Match01/Test1/X11 V_3,
+               class Match01/Test1/X11 V_4,
+               class Match01/Test1/X12 V_5,
+               class Match01/Test1/X12 V_6,
+               class Match01/Test1/X13 V_7,
+               class Match01/Test1/X13 V_8,
+               class Match01/Test1/X14 V_9,
+               class Match01/Test1/X14 V_10)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse    IL_00c9
+
+      IL_0006:  ldarg.1
+      IL_0007:  isinst     Match01/Test1
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  brfalse    IL_00c7
+
+      IL_0013:  ldarg.0
+      IL_0014:  ldfld      int32 Match01/Test1::_tag
+      IL_0019:  stloc.1
+      IL_001a:  ldloc.0
+      IL_001b:  ldfld      int32 Match01/Test1::_tag
+      IL_0020:  stloc.2
+      IL_0021:  ldloc.1
+      IL_0022:  ldloc.2
+      IL_0023:  bne.un     IL_00c5
+
+      IL_0028:  ldarg.0
+      IL_0029:  call       instance int32 Match01/Test1::get_Tag()
+      IL_002e:  switch     ( 
+                            IL_0043,
+                            IL_0062,
+                            IL_0083,
+                            IL_00a4)
+      IL_0043:  ldarg.0
+      IL_0044:  castclass  Match01/Test1/X11
+      IL_0049:  stloc.3
+      IL_004a:  ldloc.0
+      IL_004b:  castclass  Match01/Test1/X11
+      IL_0050:  stloc.s    V_4
+      IL_0052:  ldloc.3
+      IL_0053:  ldfld      int32 Match01/Test1/X11::item
+      IL_0058:  ldloc.s    V_4
+      IL_005a:  ldfld      int32 Match01/Test1/X11::item
+      IL_005f:  ceq
+      IL_0061:  ret
+
+      IL_0062:  ldarg.0
+      IL_0063:  castclass  Match01/Test1/X12
+      IL_0068:  stloc.s    V_5
+      IL_006a:  ldloc.0
+      IL_006b:  castclass  Match01/Test1/X12
+      IL_0070:  stloc.s    V_6
+      IL_0072:  ldloc.s    V_5
+      IL_0074:  ldfld      int32 Match01/Test1/X12::item
+      IL_0079:  ldloc.s    V_6
+      IL_007b:  ldfld      int32 Match01/Test1/X12::item
+      IL_0080:  ceq
+      IL_0082:  ret
+
+      IL_0083:  ldarg.0
+      IL_0084:  castclass  Match01/Test1/X13
+      IL_0089:  stloc.s    V_7
+      IL_008b:  ldloc.0
+      IL_008c:  castclass  Match01/Test1/X13
+      IL_0091:  stloc.s    V_8
+      IL_0093:  ldloc.s    V_7
+      IL_0095:  ldfld      int32 Match01/Test1/X13::item
+      IL_009a:  ldloc.s    V_8
+      IL_009c:  ldfld      int32 Match01/Test1/X13::item
+      IL_00a1:  ceq
+      IL_00a3:  ret
+
+      IL_00a4:  ldarg.0
+      IL_00a5:  castclass  Match01/Test1/X14
+      IL_00aa:  stloc.s    V_9
+      IL_00ac:  ldloc.0
+      IL_00ad:  castclass  Match01/Test1/X14
+      IL_00b2:  stloc.s    V_10
+      IL_00b4:  ldloc.s    V_9
+      IL_00b6:  ldfld      int32 Match01/Test1/X14::item
+      IL_00bb:  ldloc.s    V_10
+      IL_00bd:  ldfld      int32 Match01/Test1/X14::item
+      IL_00c2:  ceq
+      IL_00c4:  ret
+
+      IL_00c5:  ldc.i4.0
+      IL_00c6:  ret
+
+      IL_00c7:  ldc.i4.0
+      IL_00c8:  ret
+
+      IL_00c9:  ldarg.1
+      IL_00ca:  ldnull
+      IL_00cb:  cgt.un
+      IL_00cd:  ldc.i4.0
+      IL_00ce:  ceq
+      IL_00d0:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class Match01/Test1 obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (int32 V_0,
+               int32 V_1,
+               class Match01/Test1/X11 V_2,
+               class Match01/Test1/X11 V_3,
+               class Match01/Test1/X12 V_4,
+               class Match01/Test1/X12 V_5,
+               class Match01/Test1/X13 V_6,
+               class Match01/Test1/X13 V_7,
+               class Match01/Test1/X14 V_8,
+               class Match01/Test1/X14 V_9)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse    IL_00c0
+
+      IL_0006:  ldarg.1
+      IL_0007:  brfalse    IL_00be
+
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      int32 Match01/Test1::_tag
+      IL_0012:  stloc.0
+      IL_0013:  ldarg.1
+      IL_0014:  ldfld      int32 Match01/Test1::_tag
+      IL_0019:  stloc.1
+      IL_001a:  ldloc.0
+      IL_001b:  ldloc.1
+      IL_001c:  bne.un     IL_00bc
+
+      IL_0021:  ldarg.0
+      IL_0022:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0027:  switch     ( 
+                            IL_003c,
+                            IL_0059,
+                            IL_007a,
+                            IL_009b)
+      IL_003c:  ldarg.0
+      IL_003d:  castclass  Match01/Test1/X11
+      IL_0042:  stloc.2
+      IL_0043:  ldarg.1
+      IL_0044:  castclass  Match01/Test1/X11
+      IL_0049:  stloc.3
+      IL_004a:  ldloc.2
+      IL_004b:  ldfld      int32 Match01/Test1/X11::item
+      IL_0050:  ldloc.3
+      IL_0051:  ldfld      int32 Match01/Test1/X11::item
+      IL_0056:  ceq
+      IL_0058:  ret
+
+      IL_0059:  ldarg.0
+      IL_005a:  castclass  Match01/Test1/X12
+      IL_005f:  stloc.s    V_4
+      IL_0061:  ldarg.1
+      IL_0062:  castclass  Match01/Test1/X12
+      IL_0067:  stloc.s    V_5
+      IL_0069:  ldloc.s    V_4
+      IL_006b:  ldfld      int32 Match01/Test1/X12::item
+      IL_0070:  ldloc.s    V_5
+      IL_0072:  ldfld      int32 Match01/Test1/X12::item
+      IL_0077:  ceq
+      IL_0079:  ret
+
+      IL_007a:  ldarg.0
+      IL_007b:  castclass  Match01/Test1/X13
+      IL_0080:  stloc.s    V_6
+      IL_0082:  ldarg.1
+      IL_0083:  castclass  Match01/Test1/X13
+      IL_0088:  stloc.s    V_7
+      IL_008a:  ldloc.s    V_6
+      IL_008c:  ldfld      int32 Match01/Test1/X13::item
+      IL_0091:  ldloc.s    V_7
+      IL_0093:  ldfld      int32 Match01/Test1/X13::item
+      IL_0098:  ceq
+      IL_009a:  ret
+
+      IL_009b:  ldarg.0
+      IL_009c:  castclass  Match01/Test1/X14
+      IL_00a1:  stloc.s    V_8
+      IL_00a3:  ldarg.1
+      IL_00a4:  castclass  Match01/Test1/X14
+      IL_00a9:  stloc.s    V_9
+      IL_00ab:  ldloc.s    V_8
+      IL_00ad:  ldfld      int32 Match01/Test1/X14::item
+      IL_00b2:  ldloc.s    V_9
+      IL_00b4:  ldfld      int32 Match01/Test1/X14::item
+      IL_00b9:  ceq
+      IL_00bb:  ret
+
+      IL_00bc:  ldc.i4.0
+      IL_00bd:  ret
+
+      IL_00be:  ldc.i4.0
+      IL_00bf:  ret
+
+      IL_00c0:  ldarg.1
+      IL_00c1:  ldnull
+      IL_00c2:  cgt.un
+      IL_00c4:  ldc.i4.0
+      IL_00c5:  ceq
+      IL_00c7:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class Match01/Test1 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     Match01/Test1
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool Match01/Test1::Equals(class Match01/Test1)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 Match01/Test1::get_Tag()
+    } 
+    .property instance bool IsX11()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool Match01/Test1::get_IsX11()
+    } 
+    .property instance bool IsX12()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool Match01/Test1::get_IsX12()
+    } 
+    .property instance bool IsX13()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool Match01/Test1::get_IsX13()
+    } 
+    .property instance bool IsX14()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool Match01/Test1::get_IsX14()
+    } 
+  } 
+
+  .method public static int32  select1(class Match01/Test1 x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ldarg.0
+    IL_0002:  call       instance int32 Match01/Test1::get_Tag()
+    IL_0007:  switch     ( 
+                          IL_001c,
+                          IL_0028,
+                          IL_002a,
+                          IL_002c)
+    IL_001c:  ldarg.0
+    IL_001d:  castclass  Match01/Test1/X11
+    IL_0022:  ldfld      int32 Match01/Test1/X11::item
+    IL_0027:  ret
+
+    IL_0028:  ldc.i4.2
+    IL_0029:  ret
+
+    IL_002a:  ldc.i4.3
+    IL_002b:  ret
+
+    IL_002c:  ldc.i4.4
+    IL_002d:  ret
+  } 
+
+  .method public static int32  fm(class Match01/Test1 y) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       int32 Match01::select1(class Match01/Test1)
+    IL_0006:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Match01
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+.class private auto ansi serializable sealed System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+       extends [runtime]System.Enum
+{
+  .custom instance void [runtime]System.FlagsAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field public specialname rtspecialname int32 value__
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes All = int32(0xFFFFFFFF)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes None = int32(0x00000000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicParameterlessConstructor = int32(0x00000001)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicConstructors = int32(0x00000003)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicConstructors = int32(0x00000004)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicMethods = int32(0x00000008)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicMethods = int32(0x00000010)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicFields = int32(0x00000020)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicFields = int32(0x00000040)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicNestedTypes = int32(0x00000080)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicNestedTypes = int32(0x00000100)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicProperties = int32(0x00000200)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicProperties = int32(0x00000400)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicEvents = int32(0x00000800)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicEvents = int32(0x00001000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes Interfaces = int32(0x00002000)
+} 
+
+.class private auto ansi beforefieldinit System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute
+       extends [runtime]System.Attribute
+{
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private class [runtime]System.Type Type@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public specialname rtspecialname 
+          instance void  .ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType,
+                               class [runtime]System.Type Type) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Attribute::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_000d:  ldarg.0
+    IL_000e:  ldarg.2
+    IL_000f:  stfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0014:  ret
+  } 
+
+  .method public hidebysig specialname instance class [runtime]System.Type get_Type() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes get_MemberType() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_0006:  ret
+  } 
+
+  .property instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+          MemberType()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_MemberType()
+  } 
+  .property instance class [runtime]System.Type
+          Type()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_Type()
+  } 
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOn.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOn.fs.il.netcore.debug.bsl
new file mode 100644
index 00000000000..466324f3310
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOn.fs.il.netcore.debug.bsl
@@ -0,0 +1,1498 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Match01
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto autochar serializable nested public beforefieldinit Test1
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class Match01/Test1>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class Match01/Test1>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                         61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .class abstract auto ansi sealed nested public Tags
+           extends [runtime]System.Object
+    {
+      .field public static literal int32 X11 = int32(0x00000000)
+      .field public static literal int32 X12 = int32(0x00000001)
+      .field public static literal int32 X13 = int32(0x00000002)
+      .field public static literal int32 X14 = int32(0x00000003)
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit specialname X11
+           extends Match01/Test1
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
+                                                                                                                                        2B 58 31 31 40 44 65 62 75 67 54 79 70 65 50 72   
+                                                                                                                                        6F 78 79 00 00 )                                  
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                           61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                       65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.0
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.1
+        IL_0009:  stfld      int32 Match01/Test1/X11::item
+        IL_000e:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 Match01/Test1/X11::item
+        IL_0006:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X11::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit specialname X12
+           extends Match01/Test1
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
+                                                                                                                                        2B 58 31 32 40 44 65 62 75 67 54 79 70 65 50 72   
+                                                                                                                                        6F 78 79 00 00 )                                  
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                           61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                       65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.1
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.1
+        IL_0009:  stfld      int32 Match01/Test1/X12::item
+        IL_000e:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 Match01/Test1/X12::item
+        IL_0006:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 01 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X12::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit specialname X13
+           extends Match01/Test1
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
+                                                                                                                                        2B 58 31 33 40 44 65 62 75 67 54 79 70 65 50 72   
+                                                                                                                                        6F 78 79 00 00 )                                  
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                           61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                       65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.2
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.1
+        IL_0009:  stfld      int32 Match01/Test1/X13::item
+        IL_000e:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 Match01/Test1/X13::item
+        IL_0006:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 02 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X13::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit specialname X14
+           extends Match01/Test1
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
+                                                                                                                                        2B 58 31 34 40 44 65 62 75 67 54 79 70 65 50 72   
+                                                                                                                                        6F 78 79 00 00 )                                  
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                           61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                       65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.3
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.1
+        IL_0009:  stfld      int32 Match01/Test1/X14::item
+        IL_000e:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 Match01/Test1/X14::item
+        IL_0006:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 03 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X14::get_Item()
+      } 
+    } 
+
+    .class auto ansi nested assembly beforefieldinit specialname X11@DebugTypeProxy
+           extends [runtime]System.Object
+    {
+      .field assembly class Match01/Test1/X11 _obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X11 obj) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                       65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1/X11 Match01/Test1/X11@DebugTypeProxy::_obj
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1/X11 Match01/Test1/X11@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X11::item
+        IL_000b:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X11@DebugTypeProxy::get_Item()
+      } 
+    } 
+
+    .class auto ansi nested assembly beforefieldinit specialname X12@DebugTypeProxy
+           extends [runtime]System.Object
+    {
+      .field assembly class Match01/Test1/X12 _obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X12 obj) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                       65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1/X12 Match01/Test1/X12@DebugTypeProxy::_obj
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1/X12 Match01/Test1/X12@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X12::item
+        IL_000b:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 01 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X12@DebugTypeProxy::get_Item()
+      } 
+    } 
+
+    .class auto ansi nested assembly beforefieldinit specialname X13@DebugTypeProxy
+           extends [runtime]System.Object
+    {
+      .field assembly class Match01/Test1/X13 _obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X13 obj) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                       65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1/X13 Match01/Test1/X13@DebugTypeProxy::_obj
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1/X13 Match01/Test1/X13@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X13::item
+        IL_000b:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 02 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X13@DebugTypeProxy::get_Item()
+      } 
+    } 
+
+    .class auto ansi nested assembly beforefieldinit specialname X14@DebugTypeProxy
+           extends [runtime]System.Object
+    {
+      .field assembly class Match01/Test1/X14 _obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X14 obj) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                       65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1/X14 Match01/Test1/X14@DebugTypeProxy::_obj
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1/X14 Match01/Test1/X14@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X14::item
+        IL_000b:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 03 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X14@DebugTypeProxy::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit clo@4
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>
+    {
+      .field public class Match01/Test1 this
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class Match01/Test1 obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class Match01/Test1 this,
+                                   class Match01/Test1 obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance int32 Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 int32 V_1,
+                 class Match01/Test1/X11 V_2,
+                 class Match01/Test1/X11 V_3,
+                 class [runtime]System.Collections.IComparer V_4,
+                 int32 V_5,
+                 int32 V_6,
+                 class Match01/Test1/X12 V_7,
+                 class Match01/Test1/X12 V_8,
+                 class Match01/Test1/X13 V_9,
+                 class Match01/Test1/X13 V_10,
+                 class Match01/Test1/X14 V_11,
+                 class Match01/Test1/X14 V_12)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0006:  ldfld      int32 Match01/Test1::_tag
+        IL_000b:  stloc.0
+        IL_000c:  ldarg.0
+        IL_000d:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_0012:  ldfld      int32 Match01/Test1::_tag
+        IL_0017:  stloc.1
+        IL_0018:  ldloc.0
+        IL_0019:  ldloc.1
+        IL_001a:  bne.un     IL_013f
+
+        IL_001f:  ldarg.0
+        IL_0020:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0025:  call       instance int32 Match01/Test1::get_Tag()
+        IL_002a:  switch     ( 
+                              IL_003f,
+                              IL_007c,
+                              IL_00bd,
+                              IL_00fe)
+        IL_003f:  ldarg.0
+        IL_0040:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0045:  castclass  Match01/Test1/X11
+        IL_004a:  stloc.2
+        IL_004b:  ldarg.0
+        IL_004c:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_0051:  castclass  Match01/Test1/X11
+        IL_0056:  stloc.3
+        IL_0057:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_005c:  stloc.s    V_4
+        IL_005e:  ldloc.2
+        IL_005f:  ldfld      int32 Match01/Test1/X11::item
+        IL_0064:  stloc.s    V_5
+        IL_0066:  ldloc.3
+        IL_0067:  ldfld      int32 Match01/Test1/X11::item
+        IL_006c:  stloc.s    V_6
+        IL_006e:  ldloc.s    V_5
+        IL_0070:  ldloc.s    V_6
+        IL_0072:  cgt
+        IL_0074:  ldloc.s    V_5
+        IL_0076:  ldloc.s    V_6
+        IL_0078:  clt
+        IL_007a:  sub
+        IL_007b:  ret
+
+        IL_007c:  ldarg.0
+        IL_007d:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0082:  castclass  Match01/Test1/X12
+        IL_0087:  stloc.s    V_7
+        IL_0089:  ldarg.0
+        IL_008a:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_008f:  castclass  Match01/Test1/X12
+        IL_0094:  stloc.s    V_8
+        IL_0096:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_009b:  stloc.s    V_4
+        IL_009d:  ldloc.s    V_7
+        IL_009f:  ldfld      int32 Match01/Test1/X12::item
+        IL_00a4:  stloc.s    V_5
+        IL_00a6:  ldloc.s    V_8
+        IL_00a8:  ldfld      int32 Match01/Test1/X12::item
+        IL_00ad:  stloc.s    V_6
+        IL_00af:  ldloc.s    V_5
+        IL_00b1:  ldloc.s    V_6
+        IL_00b3:  cgt
+        IL_00b5:  ldloc.s    V_5
+        IL_00b7:  ldloc.s    V_6
+        IL_00b9:  clt
+        IL_00bb:  sub
+        IL_00bc:  ret
+
+        IL_00bd:  ldarg.0
+        IL_00be:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_00c3:  castclass  Match01/Test1/X13
+        IL_00c8:  stloc.s    V_9
+        IL_00ca:  ldarg.0
+        IL_00cb:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_00d0:  castclass  Match01/Test1/X13
+        IL_00d5:  stloc.s    V_10
+        IL_00d7:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_00dc:  stloc.s    V_4
+        IL_00de:  ldloc.s    V_9
+        IL_00e0:  ldfld      int32 Match01/Test1/X13::item
+        IL_00e5:  stloc.s    V_5
+        IL_00e7:  ldloc.s    V_10
+        IL_00e9:  ldfld      int32 Match01/Test1/X13::item
+        IL_00ee:  stloc.s    V_6
+        IL_00f0:  ldloc.s    V_5
+        IL_00f2:  ldloc.s    V_6
+        IL_00f4:  cgt
+        IL_00f6:  ldloc.s    V_5
+        IL_00f8:  ldloc.s    V_6
+        IL_00fa:  clt
+        IL_00fc:  sub
+        IL_00fd:  ret
+
+        IL_00fe:  ldarg.0
+        IL_00ff:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0104:  castclass  Match01/Test1/X14
+        IL_0109:  stloc.s    V_11
+        IL_010b:  ldarg.0
+        IL_010c:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_0111:  castclass  Match01/Test1/X14
+        IL_0116:  stloc.s    V_12
+        IL_0118:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_011d:  stloc.s    V_4
+        IL_011f:  ldloc.s    V_11
+        IL_0121:  ldfld      int32 Match01/Test1/X14::item
+        IL_0126:  stloc.s    V_5
+        IL_0128:  ldloc.s    V_12
+        IL_012a:  ldfld      int32 Match01/Test1/X14::item
+        IL_012f:  stloc.s    V_6
+        IL_0131:  ldloc.s    V_5
+        IL_0133:  ldloc.s    V_6
+        IL_0135:  cgt
+        IL_0137:  ldloc.s    V_5
+        IL_0139:  ldloc.s    V_6
+        IL_013b:  clt
+        IL_013d:  sub
+        IL_013e:  ret
+
+        IL_013f:  ldloc.0
+        IL_0140:  ldloc.1
+        IL_0141:  sub
+        IL_0142:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'clo@4-1'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>
+    {
+      .field public class Match01/Test1 this
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class Match01/Test1 objTemp
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class Match01/Test1 this,
+                                   class Match01/Test1 objTemp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance int32 Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 int32 V_1,
+                 class Match01/Test1/X11 V_2,
+                 class Match01/Test1/X11 V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class Match01/Test1/X12 V_6,
+                 class Match01/Test1/X12 V_7,
+                 class Match01/Test1/X13 V_8,
+                 class Match01/Test1/X13 V_9,
+                 class Match01/Test1/X14 V_10,
+                 class Match01/Test1/X14 V_11)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_0006:  ldfld      int32 Match01/Test1::_tag
+        IL_000b:  stloc.0
+        IL_000c:  ldarg.0
+        IL_000d:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_0012:  ldfld      int32 Match01/Test1::_tag
+        IL_0017:  stloc.1
+        IL_0018:  ldloc.0
+        IL_0019:  ldloc.1
+        IL_001a:  bne.un     IL_0123
+
+        IL_001f:  ldarg.0
+        IL_0020:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_0025:  call       instance int32 Match01/Test1::get_Tag()
+        IL_002a:  switch     ( 
+                              IL_003f,
+                              IL_0075,
+                              IL_00af,
+                              IL_00e9)
+        IL_003f:  ldarg.0
+        IL_0040:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_0045:  castclass  Match01/Test1/X11
+        IL_004a:  stloc.2
+        IL_004b:  ldarg.0
+        IL_004c:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_0051:  castclass  Match01/Test1/X11
+        IL_0056:  stloc.3
+        IL_0057:  ldloc.2
+        IL_0058:  ldfld      int32 Match01/Test1/X11::item
+        IL_005d:  stloc.s    V_4
+        IL_005f:  ldloc.3
+        IL_0060:  ldfld      int32 Match01/Test1/X11::item
+        IL_0065:  stloc.s    V_5
+        IL_0067:  ldloc.s    V_4
+        IL_0069:  ldloc.s    V_5
+        IL_006b:  cgt
+        IL_006d:  ldloc.s    V_4
+        IL_006f:  ldloc.s    V_5
+        IL_0071:  clt
+        IL_0073:  sub
+        IL_0074:  ret
+
+        IL_0075:  ldarg.0
+        IL_0076:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_007b:  castclass  Match01/Test1/X12
+        IL_0080:  stloc.s    V_6
+        IL_0082:  ldarg.0
+        IL_0083:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_0088:  castclass  Match01/Test1/X12
+        IL_008d:  stloc.s    V_7
+        IL_008f:  ldloc.s    V_6
+        IL_0091:  ldfld      int32 Match01/Test1/X12::item
+        IL_0096:  stloc.s    V_4
+        IL_0098:  ldloc.s    V_7
+        IL_009a:  ldfld      int32 Match01/Test1/X12::item
+        IL_009f:  stloc.s    V_5
+        IL_00a1:  ldloc.s    V_4
+        IL_00a3:  ldloc.s    V_5
+        IL_00a5:  cgt
+        IL_00a7:  ldloc.s    V_4
+        IL_00a9:  ldloc.s    V_5
+        IL_00ab:  clt
+        IL_00ad:  sub
+        IL_00ae:  ret
+
+        IL_00af:  ldarg.0
+        IL_00b0:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_00b5:  castclass  Match01/Test1/X13
+        IL_00ba:  stloc.s    V_8
+        IL_00bc:  ldarg.0
+        IL_00bd:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_00c2:  castclass  Match01/Test1/X13
+        IL_00c7:  stloc.s    V_9
+        IL_00c9:  ldloc.s    V_8
+        IL_00cb:  ldfld      int32 Match01/Test1/X13::item
+        IL_00d0:  stloc.s    V_4
+        IL_00d2:  ldloc.s    V_9
+        IL_00d4:  ldfld      int32 Match01/Test1/X13::item
+        IL_00d9:  stloc.s    V_5
+        IL_00db:  ldloc.s    V_4
+        IL_00dd:  ldloc.s    V_5
+        IL_00df:  cgt
+        IL_00e1:  ldloc.s    V_4
+        IL_00e3:  ldloc.s    V_5
+        IL_00e5:  clt
+        IL_00e7:  sub
+        IL_00e8:  ret
+
+        IL_00e9:  ldarg.0
+        IL_00ea:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_00ef:  castclass  Match01/Test1/X14
+        IL_00f4:  stloc.s    V_10
+        IL_00f6:  ldarg.0
+        IL_00f7:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_00fc:  castclass  Match01/Test1/X14
+        IL_0101:  stloc.s    V_11
+        IL_0103:  ldloc.s    V_10
+        IL_0105:  ldfld      int32 Match01/Test1/X14::item
+        IL_010a:  stloc.s    V_4
+        IL_010c:  ldloc.s    V_11
+        IL_010e:  ldfld      int32 Match01/Test1/X14::item
+        IL_0113:  stloc.s    V_5
+        IL_0115:  ldloc.s    V_4
+        IL_0117:  ldloc.s    V_5
+        IL_0119:  cgt
+        IL_011b:  ldloc.s    V_4
+        IL_011d:  ldloc.s    V_5
+        IL_011f:  clt
+        IL_0121:  sub
+        IL_0122:  ret
+
+        IL_0123:  ldloc.0
+        IL_0124:  ldloc.1
+        IL_0125:  sub
+        IL_0126:  ret
+      } 
+
+    } 
+
+    .field assembly initonly int32 _tag
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(int32 _tag) cil managed
+    {
+      .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                              class [runtime]System.Type) = ( 01 00 E0 07 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                     65 73 74 31 00 00 )                               
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 Match01/Test1::_tag
+      IL_000d:  ret
+    } 
+
+    .method public static class Match01/Test1 NewX11(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void Match01/Test1/X11::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsX11() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public static class Match01/Test1 NewX12(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void Match01/Test1/X12::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsX12() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0006:  ldc.i4.1
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public static class Match01/Test1 NewX13(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 02 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void Match01/Test1/X13::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsX13() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0006:  ldc.i4.2
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public static class Match01/Test1 NewX14(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 03 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void Match01/Test1/X14::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsX14() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0006:  ldc.i4.3
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 Match01/Test1::_tag
+      IL_0006:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class Match01/Test1>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class Match01/Test1 obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001a
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_0018
+
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  newobj     instance void Match01/Test1/clo@4::.ctor(class Match01/Test1,
+                                                                    class Match01/Test1)
+      IL_000d:  stloc.0
+      IL_000e:  ldloc.0
+      IL_000f:  ldnull
+      IL_0010:  tail.
+      IL_0012:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::Invoke(!0)
+      IL_0017:  ret
+
+      IL_0018:  ldc.i4.1
+      IL_0019:  ret
+
+      IL_001a:  ldarg.1
+      IL_001b:  brfalse.s  IL_001f
+
+      IL_001d:  ldc.i4.m1
+      IL_001e:  ret
+
+      IL_001f:  ldc.i4.0
+      IL_0020:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  Match01/Test1
+      IL_0007:  callvirt   instance int32 Match01/Test1::CompareTo(class Match01/Test1)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class Match01/Test1 V_0,
+               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  Match01/Test1
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_0026
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  Match01/Test1
+      IL_0010:  brfalse.s  IL_0024
+
+      IL_0012:  ldarg.0
+      IL_0013:  ldloc.0
+      IL_0014:  newobj     instance void Match01/Test1/'clo@4-1'::.ctor(class Match01/Test1,
+                                                                        class Match01/Test1)
+      IL_0019:  stloc.1
+      IL_001a:  ldloc.1
+      IL_001b:  ldnull
+      IL_001c:  tail.
+      IL_001e:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::Invoke(!0)
+      IL_0023:  ret
+
+      IL_0024:  ldc.i4.1
+      IL_0025:  ret
+
+      IL_0026:  ldarg.1
+      IL_0027:  unbox.any  Match01/Test1
+      IL_002c:  brfalse.s  IL_0030
+
+      IL_002e:  ldc.i4.m1
+      IL_002f:  ret
+
+      IL_0030:  ldc.i4.0
+      IL_0031:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class Match01/Test1/X11 V_1,
+               class Match01/Test1/X12 V_2,
+               class Match01/Test1/X13 V_3,
+               class Match01/Test1/X14 V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse    IL_00a5
+
+      IL_0006:  ldc.i4.0
+      IL_0007:  stloc.0
+      IL_0008:  ldarg.0
+      IL_0009:  call       instance int32 Match01/Test1::get_Tag()
+      IL_000e:  switch     ( 
+                            IL_0023,
+                            IL_0043,
+                            IL_0063,
+                            IL_0083)
+      IL_0023:  ldarg.0
+      IL_0024:  castclass  Match01/Test1/X11
+      IL_0029:  stloc.1
+      IL_002a:  ldc.i4.0
+      IL_002b:  stloc.0
+      IL_002c:  ldc.i4     0x9e3779b9
+      IL_0031:  ldloc.1
+      IL_0032:  ldfld      int32 Match01/Test1/X11::item
+      IL_0037:  ldloc.0
+      IL_0038:  ldc.i4.6
+      IL_0039:  shl
+      IL_003a:  ldloc.0
+      IL_003b:  ldc.i4.2
+      IL_003c:  shr
+      IL_003d:  add
+      IL_003e:  add
+      IL_003f:  add
+      IL_0040:  stloc.0
+      IL_0041:  ldloc.0
+      IL_0042:  ret
+
+      IL_0043:  ldarg.0
+      IL_0044:  castclass  Match01/Test1/X12
+      IL_0049:  stloc.2
+      IL_004a:  ldc.i4.1
+      IL_004b:  stloc.0
+      IL_004c:  ldc.i4     0x9e3779b9
+      IL_0051:  ldloc.2
+      IL_0052:  ldfld      int32 Match01/Test1/X12::item
+      IL_0057:  ldloc.0
+      IL_0058:  ldc.i4.6
+      IL_0059:  shl
+      IL_005a:  ldloc.0
+      IL_005b:  ldc.i4.2
+      IL_005c:  shr
+      IL_005d:  add
+      IL_005e:  add
+      IL_005f:  add
+      IL_0060:  stloc.0
+      IL_0061:  ldloc.0
+      IL_0062:  ret
+
+      IL_0063:  ldarg.0
+      IL_0064:  castclass  Match01/Test1/X13
+      IL_0069:  stloc.3
+      IL_006a:  ldc.i4.2
+      IL_006b:  stloc.0
+      IL_006c:  ldc.i4     0x9e3779b9
+      IL_0071:  ldloc.3
+      IL_0072:  ldfld      int32 Match01/Test1/X13::item
+      IL_0077:  ldloc.0
+      IL_0078:  ldc.i4.6
+      IL_0079:  shl
+      IL_007a:  ldloc.0
+      IL_007b:  ldc.i4.2
+      IL_007c:  shr
+      IL_007d:  add
+      IL_007e:  add
+      IL_007f:  add
+      IL_0080:  stloc.0
+      IL_0081:  ldloc.0
+      IL_0082:  ret
+
+      IL_0083:  ldarg.0
+      IL_0084:  castclass  Match01/Test1/X14
+      IL_0089:  stloc.s    V_4
+      IL_008b:  ldc.i4.3
+      IL_008c:  stloc.0
+      IL_008d:  ldc.i4     0x9e3779b9
+      IL_0092:  ldloc.s    V_4
+      IL_0094:  ldfld      int32 Match01/Test1/X14::item
+      IL_0099:  ldloc.0
+      IL_009a:  ldc.i4.6
+      IL_009b:  shl
+      IL_009c:  ldloc.0
+      IL_009d:  ldc.i4.2
+      IL_009e:  shr
+      IL_009f:  add
+      IL_00a0:  add
+      IL_00a1:  add
+      IL_00a2:  stloc.0
+      IL_00a3:  ldloc.0
+      IL_00a4:  ret
+
+      IL_00a5:  ldc.i4.0
+      IL_00a6:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 Match01/Test1::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class Match01/Test1 V_0,
+               int32 V_1,
+               int32 V_2,
+               class Match01/Test1/X11 V_3,
+               class Match01/Test1/X11 V_4,
+               class Match01/Test1/X12 V_5,
+               class Match01/Test1/X12 V_6,
+               class Match01/Test1/X13 V_7,
+               class Match01/Test1/X13 V_8,
+               class Match01/Test1/X14 V_9,
+               class Match01/Test1/X14 V_10)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse    IL_00c9
+
+      IL_0006:  ldarg.1
+      IL_0007:  isinst     Match01/Test1
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  brfalse    IL_00c7
+
+      IL_0013:  ldarg.0
+      IL_0014:  ldfld      int32 Match01/Test1::_tag
+      IL_0019:  stloc.1
+      IL_001a:  ldloc.0
+      IL_001b:  ldfld      int32 Match01/Test1::_tag
+      IL_0020:  stloc.2
+      IL_0021:  ldloc.1
+      IL_0022:  ldloc.2
+      IL_0023:  bne.un     IL_00c5
+
+      IL_0028:  ldarg.0
+      IL_0029:  call       instance int32 Match01/Test1::get_Tag()
+      IL_002e:  switch     ( 
+                            IL_0043,
+                            IL_0062,
+                            IL_0083,
+                            IL_00a4)
+      IL_0043:  ldarg.0
+      IL_0044:  castclass  Match01/Test1/X11
+      IL_0049:  stloc.3
+      IL_004a:  ldloc.0
+      IL_004b:  castclass  Match01/Test1/X11
+      IL_0050:  stloc.s    V_4
+      IL_0052:  ldloc.3
+      IL_0053:  ldfld      int32 Match01/Test1/X11::item
+      IL_0058:  ldloc.s    V_4
+      IL_005a:  ldfld      int32 Match01/Test1/X11::item
+      IL_005f:  ceq
+      IL_0061:  ret
+
+      IL_0062:  ldarg.0
+      IL_0063:  castclass  Match01/Test1/X12
+      IL_0068:  stloc.s    V_5
+      IL_006a:  ldloc.0
+      IL_006b:  castclass  Match01/Test1/X12
+      IL_0070:  stloc.s    V_6
+      IL_0072:  ldloc.s    V_5
+      IL_0074:  ldfld      int32 Match01/Test1/X12::item
+      IL_0079:  ldloc.s    V_6
+      IL_007b:  ldfld      int32 Match01/Test1/X12::item
+      IL_0080:  ceq
+      IL_0082:  ret
+
+      IL_0083:  ldarg.0
+      IL_0084:  castclass  Match01/Test1/X13
+      IL_0089:  stloc.s    V_7
+      IL_008b:  ldloc.0
+      IL_008c:  castclass  Match01/Test1/X13
+      IL_0091:  stloc.s    V_8
+      IL_0093:  ldloc.s    V_7
+      IL_0095:  ldfld      int32 Match01/Test1/X13::item
+      IL_009a:  ldloc.s    V_8
+      IL_009c:  ldfld      int32 Match01/Test1/X13::item
+      IL_00a1:  ceq
+      IL_00a3:  ret
+
+      IL_00a4:  ldarg.0
+      IL_00a5:  castclass  Match01/Test1/X14
+      IL_00aa:  stloc.s    V_9
+      IL_00ac:  ldloc.0
+      IL_00ad:  castclass  Match01/Test1/X14
+      IL_00b2:  stloc.s    V_10
+      IL_00b4:  ldloc.s    V_9
+      IL_00b6:  ldfld      int32 Match01/Test1/X14::item
+      IL_00bb:  ldloc.s    V_10
+      IL_00bd:  ldfld      int32 Match01/Test1/X14::item
+      IL_00c2:  ceq
+      IL_00c4:  ret
+
+      IL_00c5:  ldc.i4.0
+      IL_00c6:  ret
+
+      IL_00c7:  ldc.i4.0
+      IL_00c8:  ret
+
+      IL_00c9:  ldarg.1
+      IL_00ca:  ldnull
+      IL_00cb:  cgt.un
+      IL_00cd:  ldc.i4.0
+      IL_00ce:  ceq
+      IL_00d0:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class Match01/Test1 obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (int32 V_0,
+               int32 V_1,
+               class Match01/Test1/X11 V_2,
+               class Match01/Test1/X11 V_3,
+               class Match01/Test1/X12 V_4,
+               class Match01/Test1/X12 V_5,
+               class Match01/Test1/X13 V_6,
+               class Match01/Test1/X13 V_7,
+               class Match01/Test1/X14 V_8,
+               class Match01/Test1/X14 V_9)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse    IL_00c0
+
+      IL_0006:  ldarg.1
+      IL_0007:  brfalse    IL_00be
+
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      int32 Match01/Test1::_tag
+      IL_0012:  stloc.0
+      IL_0013:  ldarg.1
+      IL_0014:  ldfld      int32 Match01/Test1::_tag
+      IL_0019:  stloc.1
+      IL_001a:  ldloc.0
+      IL_001b:  ldloc.1
+      IL_001c:  bne.un     IL_00bc
+
+      IL_0021:  ldarg.0
+      IL_0022:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0027:  switch     ( 
+                            IL_003c,
+                            IL_0059,
+                            IL_007a,
+                            IL_009b)
+      IL_003c:  ldarg.0
+      IL_003d:  castclass  Match01/Test1/X11
+      IL_0042:  stloc.2
+      IL_0043:  ldarg.1
+      IL_0044:  castclass  Match01/Test1/X11
+      IL_0049:  stloc.3
+      IL_004a:  ldloc.2
+      IL_004b:  ldfld      int32 Match01/Test1/X11::item
+      IL_0050:  ldloc.3
+      IL_0051:  ldfld      int32 Match01/Test1/X11::item
+      IL_0056:  ceq
+      IL_0058:  ret
+
+      IL_0059:  ldarg.0
+      IL_005a:  castclass  Match01/Test1/X12
+      IL_005f:  stloc.s    V_4
+      IL_0061:  ldarg.1
+      IL_0062:  castclass  Match01/Test1/X12
+      IL_0067:  stloc.s    V_5
+      IL_0069:  ldloc.s    V_4
+      IL_006b:  ldfld      int32 Match01/Test1/X12::item
+      IL_0070:  ldloc.s    V_5
+      IL_0072:  ldfld      int32 Match01/Test1/X12::item
+      IL_0077:  ceq
+      IL_0079:  ret
+
+      IL_007a:  ldarg.0
+      IL_007b:  castclass  Match01/Test1/X13
+      IL_0080:  stloc.s    V_6
+      IL_0082:  ldarg.1
+      IL_0083:  castclass  Match01/Test1/X13
+      IL_0088:  stloc.s    V_7
+      IL_008a:  ldloc.s    V_6
+      IL_008c:  ldfld      int32 Match01/Test1/X13::item
+      IL_0091:  ldloc.s    V_7
+      IL_0093:  ldfld      int32 Match01/Test1/X13::item
+      IL_0098:  ceq
+      IL_009a:  ret
+
+      IL_009b:  ldarg.0
+      IL_009c:  castclass  Match01/Test1/X14
+      IL_00a1:  stloc.s    V_8
+      IL_00a3:  ldarg.1
+      IL_00a4:  castclass  Match01/Test1/X14
+      IL_00a9:  stloc.s    V_9
+      IL_00ab:  ldloc.s    V_8
+      IL_00ad:  ldfld      int32 Match01/Test1/X14::item
+      IL_00b2:  ldloc.s    V_9
+      IL_00b4:  ldfld      int32 Match01/Test1/X14::item
+      IL_00b9:  ceq
+      IL_00bb:  ret
+
+      IL_00bc:  ldc.i4.0
+      IL_00bd:  ret
+
+      IL_00be:  ldc.i4.0
+      IL_00bf:  ret
+
+      IL_00c0:  ldarg.1
+      IL_00c1:  ldnull
+      IL_00c2:  cgt.un
+      IL_00c4:  ldc.i4.0
+      IL_00c5:  ceq
+      IL_00c7:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class Match01/Test1 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     Match01/Test1
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool Match01/Test1::Equals(class Match01/Test1)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 Match01/Test1::get_Tag()
+    } 
+    .property instance bool IsX11()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool Match01/Test1::get_IsX11()
+    } 
+    .property instance bool IsX12()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool Match01/Test1::get_IsX12()
+    } 
+    .property instance bool IsX13()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool Match01/Test1::get_IsX13()
+    } 
+    .property instance bool IsX14()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool Match01/Test1::get_IsX14()
+    } 
+  } 
+
+  .method public static int32  select1(class Match01/Test1 x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ldarg.0
+    IL_0002:  call       instance int32 Match01/Test1::get_Tag()
+    IL_0007:  switch     ( 
+                          IL_001c,
+                          IL_0028,
+                          IL_002a,
+                          IL_002c)
+    IL_001c:  ldarg.0
+    IL_001d:  castclass  Match01/Test1/X11
+    IL_0022:  ldfld      int32 Match01/Test1/X11::item
+    IL_0027:  ret
+
+    IL_0028:  ldc.i4.2
+    IL_0029:  ret
+
+    IL_002a:  ldc.i4.3
+    IL_002b:  ret
+
+    IL_002c:  ldc.i4.4
+    IL_002d:  ret
+  } 
+
+  .method public static int32  fm(class Match01/Test1 y) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       int32 Match01::select1(class Match01/Test1)
+    IL_0006:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Match01
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOn.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOn.fs.il.netcore.release.bsl
new file mode 100644
index 00000000000..0674871e93e
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Inlining/Match01_RealInternalSignatureOn.fs.il.netcore.release.bsl
@@ -0,0 +1,1509 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Match01
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto autochar serializable nested public beforefieldinit Test1
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class Match01/Test1>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class Match01/Test1>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                         61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .class abstract auto ansi sealed nested public Tags
+           extends [runtime]System.Object
+    {
+      .field public static literal int32 X11 = int32(0x00000000)
+      .field public static literal int32 X12 = int32(0x00000001)
+      .field public static literal int32 X13 = int32(0x00000002)
+      .field public static literal int32 X14 = int32(0x00000003)
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit specialname X11
+           extends Match01/Test1
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
+                                                                                                                                        2B 58 31 31 40 44 65 62 75 67 54 79 70 65 50 72   
+                                                                                                                                        6F 78 79 00 00 )                                  
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                           61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                       65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.0
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.1
+        IL_0009:  stfld      int32 Match01/Test1/X11::item
+        IL_000e:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 Match01/Test1/X11::item
+        IL_0006:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X11::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit specialname X12
+           extends Match01/Test1
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
+                                                                                                                                        2B 58 31 32 40 44 65 62 75 67 54 79 70 65 50 72   
+                                                                                                                                        6F 78 79 00 00 )                                  
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                           61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                       65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.1
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.1
+        IL_0009:  stfld      int32 Match01/Test1/X12::item
+        IL_000e:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 Match01/Test1/X12::item
+        IL_0006:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 01 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X12::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit specialname X13
+           extends Match01/Test1
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
+                                                                                                                                        2B 58 31 33 40 44 65 62 75 67 54 79 70 65 50 72   
+                                                                                                                                        6F 78 79 00 00 )                                  
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                           61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                       65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.2
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.1
+        IL_0009:  stfld      int32 Match01/Test1/X13::item
+        IL_000e:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 Match01/Test1/X13::item
+        IL_0006:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 02 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X13::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit specialname X14
+           extends Match01/Test1
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerTypeProxyAttribute::.ctor(class [runtime]System.Type) = ( 01 00 20 4D 61 74 63 68 30 31 2B 54 65 73 74 31   
+                                                                                                                                        2B 58 31 34 40 44 65 62 75 67 54 79 70 65 50 72   
+                                                                                                                                        6F 78 79 00 00 )                                  
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                           61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                       65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.3
+        IL_0002:  call       instance void Match01/Test1::.ctor(int32)
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.1
+        IL_0009:  stfld      int32 Match01/Test1/X14::item
+        IL_000e:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 Match01/Test1/X14::item
+        IL_0006:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 03 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X14::get_Item()
+      } 
+    } 
+
+    .class auto ansi nested assembly beforefieldinit specialname X11@DebugTypeProxy
+           extends [runtime]System.Object
+    {
+      .field assembly class Match01/Test1/X11 _obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X11 obj) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                       65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1/X11 Match01/Test1/X11@DebugTypeProxy::_obj
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1/X11 Match01/Test1/X11@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X11::item
+        IL_000b:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X11@DebugTypeProxy::get_Item()
+      } 
+    } 
+
+    .class auto ansi nested assembly beforefieldinit specialname X12@DebugTypeProxy
+           extends [runtime]System.Object
+    {
+      .field assembly class Match01/Test1/X12 _obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X12 obj) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                       65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1/X12 Match01/Test1/X12@DebugTypeProxy::_obj
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1/X12 Match01/Test1/X12@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X12::item
+        IL_000b:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 01 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X12@DebugTypeProxy::get_Item()
+      } 
+    } 
+
+    .class auto ansi nested assembly beforefieldinit specialname X13@DebugTypeProxy
+           extends [runtime]System.Object
+    {
+      .field assembly class Match01/Test1/X13 _obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X13 obj) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                       65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1/X13 Match01/Test1/X13@DebugTypeProxy::_obj
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1/X13 Match01/Test1/X13@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X13::item
+        IL_000b:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 02 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X13@DebugTypeProxy::get_Item()
+      } 
+    } 
+
+    .class auto ansi nested assembly beforefieldinit specialname X14@DebugTypeProxy
+           extends [runtime]System.Object
+    {
+      .field assembly class Match01/Test1/X14 _obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname instance void  .ctor(class Match01/Test1/X14 obj) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                       65 73 74 31 00 00 )                               
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1/X14 Match01/Test1/X14@DebugTypeProxy::_obj
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1/X14 Match01/Test1/X14@DebugTypeProxy::_obj
+        IL_0006:  ldfld      int32 Match01/Test1/X14::item
+        IL_000b:  ret
+      } 
+
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 03 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 Match01/Test1/X14@DebugTypeProxy::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit clo@4
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>
+    {
+      .field public class Match01/Test1 this
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class Match01/Test1 obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class Match01/Test1 this,
+                                   class Match01/Test1 obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance int32 Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 int32 V_1,
+                 class Match01/Test1/X11 V_2,
+                 class Match01/Test1/X11 V_3,
+                 class [runtime]System.Collections.IComparer V_4,
+                 int32 V_5,
+                 int32 V_6,
+                 class Match01/Test1/X12 V_7,
+                 class Match01/Test1/X12 V_8,
+                 class Match01/Test1/X13 V_9,
+                 class Match01/Test1/X13 V_10,
+                 class Match01/Test1/X14 V_11,
+                 class Match01/Test1/X14 V_12)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0006:  ldfld      int32 Match01/Test1::_tag
+        IL_000b:  stloc.0
+        IL_000c:  ldarg.0
+        IL_000d:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_0012:  ldfld      int32 Match01/Test1::_tag
+        IL_0017:  stloc.1
+        IL_0018:  ldloc.0
+        IL_0019:  ldloc.1
+        IL_001a:  bne.un     IL_013f
+
+        IL_001f:  ldarg.0
+        IL_0020:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0025:  call       instance int32 Match01/Test1::get_Tag()
+        IL_002a:  switch     ( 
+                              IL_003f,
+                              IL_007c,
+                              IL_00bd,
+                              IL_00fe)
+        IL_003f:  ldarg.0
+        IL_0040:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0045:  castclass  Match01/Test1/X11
+        IL_004a:  stloc.2
+        IL_004b:  ldarg.0
+        IL_004c:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_0051:  castclass  Match01/Test1/X11
+        IL_0056:  stloc.3
+        IL_0057:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_005c:  stloc.s    V_4
+        IL_005e:  ldloc.2
+        IL_005f:  ldfld      int32 Match01/Test1/X11::item
+        IL_0064:  stloc.s    V_5
+        IL_0066:  ldloc.3
+        IL_0067:  ldfld      int32 Match01/Test1/X11::item
+        IL_006c:  stloc.s    V_6
+        IL_006e:  ldloc.s    V_5
+        IL_0070:  ldloc.s    V_6
+        IL_0072:  cgt
+        IL_0074:  ldloc.s    V_5
+        IL_0076:  ldloc.s    V_6
+        IL_0078:  clt
+        IL_007a:  sub
+        IL_007b:  ret
+
+        IL_007c:  ldarg.0
+        IL_007d:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0082:  castclass  Match01/Test1/X12
+        IL_0087:  stloc.s    V_7
+        IL_0089:  ldarg.0
+        IL_008a:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_008f:  castclass  Match01/Test1/X12
+        IL_0094:  stloc.s    V_8
+        IL_0096:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_009b:  stloc.s    V_4
+        IL_009d:  ldloc.s    V_7
+        IL_009f:  ldfld      int32 Match01/Test1/X12::item
+        IL_00a4:  stloc.s    V_5
+        IL_00a6:  ldloc.s    V_8
+        IL_00a8:  ldfld      int32 Match01/Test1/X12::item
+        IL_00ad:  stloc.s    V_6
+        IL_00af:  ldloc.s    V_5
+        IL_00b1:  ldloc.s    V_6
+        IL_00b3:  cgt
+        IL_00b5:  ldloc.s    V_5
+        IL_00b7:  ldloc.s    V_6
+        IL_00b9:  clt
+        IL_00bb:  sub
+        IL_00bc:  ret
+
+        IL_00bd:  ldarg.0
+        IL_00be:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_00c3:  castclass  Match01/Test1/X13
+        IL_00c8:  stloc.s    V_9
+        IL_00ca:  ldarg.0
+        IL_00cb:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_00d0:  castclass  Match01/Test1/X13
+        IL_00d5:  stloc.s    V_10
+        IL_00d7:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_00dc:  stloc.s    V_4
+        IL_00de:  ldloc.s    V_9
+        IL_00e0:  ldfld      int32 Match01/Test1/X13::item
+        IL_00e5:  stloc.s    V_5
+        IL_00e7:  ldloc.s    V_10
+        IL_00e9:  ldfld      int32 Match01/Test1/X13::item
+        IL_00ee:  stloc.s    V_6
+        IL_00f0:  ldloc.s    V_5
+        IL_00f2:  ldloc.s    V_6
+        IL_00f4:  cgt
+        IL_00f6:  ldloc.s    V_5
+        IL_00f8:  ldloc.s    V_6
+        IL_00fa:  clt
+        IL_00fc:  sub
+        IL_00fd:  ret
+
+        IL_00fe:  ldarg.0
+        IL_00ff:  ldfld      class Match01/Test1 Match01/Test1/clo@4::this
+        IL_0104:  castclass  Match01/Test1/X14
+        IL_0109:  stloc.s    V_11
+        IL_010b:  ldarg.0
+        IL_010c:  ldfld      class Match01/Test1 Match01/Test1/clo@4::obj
+        IL_0111:  castclass  Match01/Test1/X14
+        IL_0116:  stloc.s    V_12
+        IL_0118:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_011d:  stloc.s    V_4
+        IL_011f:  ldloc.s    V_11
+        IL_0121:  ldfld      int32 Match01/Test1/X14::item
+        IL_0126:  stloc.s    V_5
+        IL_0128:  ldloc.s    V_12
+        IL_012a:  ldfld      int32 Match01/Test1/X14::item
+        IL_012f:  stloc.s    V_6
+        IL_0131:  ldloc.s    V_5
+        IL_0133:  ldloc.s    V_6
+        IL_0135:  cgt
+        IL_0137:  ldloc.s    V_5
+        IL_0139:  ldloc.s    V_6
+        IL_013b:  clt
+        IL_013d:  sub
+        IL_013e:  ret
+
+        IL_013f:  ldloc.0
+        IL_0140:  ldloc.1
+        IL_0141:  sub
+        IL_0142:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'clo@4-1'
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>
+    {
+      .field public class Match01/Test1 this
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public object obj
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class Match01/Test1 objTemp
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname 
+              instance void  .ctor(class Match01/Test1 this,
+                                   object obj,
+                                   class Match01/Test1 objTemp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_000d:  ldarg.0
+        IL_000e:  ldarg.2
+        IL_000f:  stfld      object Match01/Test1/'clo@4-1'::obj
+        IL_0014:  ldarg.0
+        IL_0015:  ldarg.3
+        IL_0016:  stfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_001b:  ret
+      } 
+
+      .method public strict virtual instance int32 Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 int32 V_1,
+                 class Match01/Test1/X11 V_2,
+                 class Match01/Test1/X11 V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class Match01/Test1/X12 V_6,
+                 class Match01/Test1/X12 V_7,
+                 class Match01/Test1/X13 V_8,
+                 class Match01/Test1/X13 V_9,
+                 class Match01/Test1/X14 V_10,
+                 class Match01/Test1/X14 V_11)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      object Match01/Test1/'clo@4-1'::obj
+        IL_0006:  unbox.any  Match01/Test1
+        IL_000b:  brfalse    IL_0137
+
+        IL_0010:  ldarg.0
+        IL_0011:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_0016:  ldfld      int32 Match01/Test1::_tag
+        IL_001b:  stloc.0
+        IL_001c:  ldarg.0
+        IL_001d:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_0022:  ldfld      int32 Match01/Test1::_tag
+        IL_0027:  stloc.1
+        IL_0028:  ldloc.0
+        IL_0029:  ldloc.1
+        IL_002a:  bne.un     IL_0133
+
+        IL_002f:  ldarg.0
+        IL_0030:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_0035:  call       instance int32 Match01/Test1::get_Tag()
+        IL_003a:  switch     ( 
+                              IL_004f,
+                              IL_0085,
+                              IL_00bf,
+                              IL_00f9)
+        IL_004f:  ldarg.0
+        IL_0050:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_0055:  castclass  Match01/Test1/X11
+        IL_005a:  stloc.2
+        IL_005b:  ldarg.0
+        IL_005c:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_0061:  castclass  Match01/Test1/X11
+        IL_0066:  stloc.3
+        IL_0067:  ldloc.2
+        IL_0068:  ldfld      int32 Match01/Test1/X11::item
+        IL_006d:  stloc.s    V_4
+        IL_006f:  ldloc.3
+        IL_0070:  ldfld      int32 Match01/Test1/X11::item
+        IL_0075:  stloc.s    V_5
+        IL_0077:  ldloc.s    V_4
+        IL_0079:  ldloc.s    V_5
+        IL_007b:  cgt
+        IL_007d:  ldloc.s    V_4
+        IL_007f:  ldloc.s    V_5
+        IL_0081:  clt
+        IL_0083:  sub
+        IL_0084:  ret
+
+        IL_0085:  ldarg.0
+        IL_0086:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_008b:  castclass  Match01/Test1/X12
+        IL_0090:  stloc.s    V_6
+        IL_0092:  ldarg.0
+        IL_0093:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_0098:  castclass  Match01/Test1/X12
+        IL_009d:  stloc.s    V_7
+        IL_009f:  ldloc.s    V_6
+        IL_00a1:  ldfld      int32 Match01/Test1/X12::item
+        IL_00a6:  stloc.s    V_4
+        IL_00a8:  ldloc.s    V_7
+        IL_00aa:  ldfld      int32 Match01/Test1/X12::item
+        IL_00af:  stloc.s    V_5
+        IL_00b1:  ldloc.s    V_4
+        IL_00b3:  ldloc.s    V_5
+        IL_00b5:  cgt
+        IL_00b7:  ldloc.s    V_4
+        IL_00b9:  ldloc.s    V_5
+        IL_00bb:  clt
+        IL_00bd:  sub
+        IL_00be:  ret
+
+        IL_00bf:  ldarg.0
+        IL_00c0:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_00c5:  castclass  Match01/Test1/X13
+        IL_00ca:  stloc.s    V_8
+        IL_00cc:  ldarg.0
+        IL_00cd:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_00d2:  castclass  Match01/Test1/X13
+        IL_00d7:  stloc.s    V_9
+        IL_00d9:  ldloc.s    V_8
+        IL_00db:  ldfld      int32 Match01/Test1/X13::item
+        IL_00e0:  stloc.s    V_4
+        IL_00e2:  ldloc.s    V_9
+        IL_00e4:  ldfld      int32 Match01/Test1/X13::item
+        IL_00e9:  stloc.s    V_5
+        IL_00eb:  ldloc.s    V_4
+        IL_00ed:  ldloc.s    V_5
+        IL_00ef:  cgt
+        IL_00f1:  ldloc.s    V_4
+        IL_00f3:  ldloc.s    V_5
+        IL_00f5:  clt
+        IL_00f7:  sub
+        IL_00f8:  ret
+
+        IL_00f9:  ldarg.0
+        IL_00fa:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::this
+        IL_00ff:  castclass  Match01/Test1/X14
+        IL_0104:  stloc.s    V_10
+        IL_0106:  ldarg.0
+        IL_0107:  ldfld      class Match01/Test1 Match01/Test1/'clo@4-1'::objTemp
+        IL_010c:  castclass  Match01/Test1/X14
+        IL_0111:  stloc.s    V_11
+        IL_0113:  ldloc.s    V_10
+        IL_0115:  ldfld      int32 Match01/Test1/X14::item
+        IL_011a:  stloc.s    V_4
+        IL_011c:  ldloc.s    V_11
+        IL_011e:  ldfld      int32 Match01/Test1/X14::item
+        IL_0123:  stloc.s    V_5
+        IL_0125:  ldloc.s    V_4
+        IL_0127:  ldloc.s    V_5
+        IL_0129:  cgt
+        IL_012b:  ldloc.s    V_4
+        IL_012d:  ldloc.s    V_5
+        IL_012f:  clt
+        IL_0131:  sub
+        IL_0132:  ret
+
+        IL_0133:  ldloc.0
+        IL_0134:  ldloc.1
+        IL_0135:  sub
+        IL_0136:  ret
+
+        IL_0137:  ldc.i4.1
+        IL_0138:  ret
+      } 
+
+    } 
+
+    .field assembly initonly int32 _tag
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(int32 _tag) cil managed
+    {
+      .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                              class [runtime]System.Type) = ( 01 00 E0 07 00 00 0D 4D 61 74 63 68 30 31 2B 54   
+                                                                                                                                                     65 73 74 31 00 00 )                               
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 Match01/Test1::_tag
+      IL_000d:  ret
+    } 
+
+    .method public static class Match01/Test1 NewX11(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void Match01/Test1/X11::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsX11() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public static class Match01/Test1 NewX12(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void Match01/Test1/X12::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsX12() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0006:  ldc.i4.1
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public static class Match01/Test1 NewX13(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 02 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void Match01/Test1/X13::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsX13() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0006:  ldc.i4.2
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public static class Match01/Test1 NewX14(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 03 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void Match01/Test1/X14::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance bool get_IsX14() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0006:  ldc.i4.3
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 Match01/Test1::_tag
+      IL_0006:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class Match01/Test1>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class Match01/Test1,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class Match01/Test1 obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001a
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_0018
+
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  newobj     instance void Match01/Test1/clo@4::.ctor(class Match01/Test1,
+                                                                    class Match01/Test1)
+      IL_000d:  stloc.0
+      IL_000e:  ldloc.0
+      IL_000f:  ldnull
+      IL_0010:  tail.
+      IL_0012:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::Invoke(!0)
+      IL_0017:  ret
+
+      IL_0018:  ldc.i4.1
+      IL_0019:  ret
+
+      IL_001a:  ldarg.1
+      IL_001b:  brfalse.s  IL_001f
+
+      IL_001d:  ldc.i4.m1
+      IL_001e:  ret
+
+      IL_001f:  ldc.i4.0
+      IL_0020:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  Match01/Test1
+      IL_0007:  callvirt   instance int32 Match01/Test1::CompareTo(class Match01/Test1)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class Match01/Test1 V_0,
+               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  Match01/Test1
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_001d
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldarg.1
+      IL_000c:  ldloc.0
+      IL_000d:  newobj     instance void Match01/Test1/'clo@4-1'::.ctor(class Match01/Test1,
+                                                                        object,
+                                                                        class Match01/Test1)
+      IL_0012:  stloc.1
+      IL_0013:  ldloc.1
+      IL_0014:  ldnull
+      IL_0015:  tail.
+      IL_0017:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::Invoke(!0)
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  unbox.any  Match01/Test1
+      IL_0023:  brfalse.s  IL_0027
+
+      IL_0025:  ldc.i4.m1
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class Match01/Test1/X11 V_1,
+               class Match01/Test1/X12 V_2,
+               class Match01/Test1/X13 V_3,
+               class Match01/Test1/X14 V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse    IL_00a5
+
+      IL_0006:  ldc.i4.0
+      IL_0007:  stloc.0
+      IL_0008:  ldarg.0
+      IL_0009:  call       instance int32 Match01/Test1::get_Tag()
+      IL_000e:  switch     ( 
+                            IL_0023,
+                            IL_0043,
+                            IL_0063,
+                            IL_0083)
+      IL_0023:  ldarg.0
+      IL_0024:  castclass  Match01/Test1/X11
+      IL_0029:  stloc.1
+      IL_002a:  ldc.i4.0
+      IL_002b:  stloc.0
+      IL_002c:  ldc.i4     0x9e3779b9
+      IL_0031:  ldloc.1
+      IL_0032:  ldfld      int32 Match01/Test1/X11::item
+      IL_0037:  ldloc.0
+      IL_0038:  ldc.i4.6
+      IL_0039:  shl
+      IL_003a:  ldloc.0
+      IL_003b:  ldc.i4.2
+      IL_003c:  shr
+      IL_003d:  add
+      IL_003e:  add
+      IL_003f:  add
+      IL_0040:  stloc.0
+      IL_0041:  ldloc.0
+      IL_0042:  ret
+
+      IL_0043:  ldarg.0
+      IL_0044:  castclass  Match01/Test1/X12
+      IL_0049:  stloc.2
+      IL_004a:  ldc.i4.1
+      IL_004b:  stloc.0
+      IL_004c:  ldc.i4     0x9e3779b9
+      IL_0051:  ldloc.2
+      IL_0052:  ldfld      int32 Match01/Test1/X12::item
+      IL_0057:  ldloc.0
+      IL_0058:  ldc.i4.6
+      IL_0059:  shl
+      IL_005a:  ldloc.0
+      IL_005b:  ldc.i4.2
+      IL_005c:  shr
+      IL_005d:  add
+      IL_005e:  add
+      IL_005f:  add
+      IL_0060:  stloc.0
+      IL_0061:  ldloc.0
+      IL_0062:  ret
+
+      IL_0063:  ldarg.0
+      IL_0064:  castclass  Match01/Test1/X13
+      IL_0069:  stloc.3
+      IL_006a:  ldc.i4.2
+      IL_006b:  stloc.0
+      IL_006c:  ldc.i4     0x9e3779b9
+      IL_0071:  ldloc.3
+      IL_0072:  ldfld      int32 Match01/Test1/X13::item
+      IL_0077:  ldloc.0
+      IL_0078:  ldc.i4.6
+      IL_0079:  shl
+      IL_007a:  ldloc.0
+      IL_007b:  ldc.i4.2
+      IL_007c:  shr
+      IL_007d:  add
+      IL_007e:  add
+      IL_007f:  add
+      IL_0080:  stloc.0
+      IL_0081:  ldloc.0
+      IL_0082:  ret
+
+      IL_0083:  ldarg.0
+      IL_0084:  castclass  Match01/Test1/X14
+      IL_0089:  stloc.s    V_4
+      IL_008b:  ldc.i4.3
+      IL_008c:  stloc.0
+      IL_008d:  ldc.i4     0x9e3779b9
+      IL_0092:  ldloc.s    V_4
+      IL_0094:  ldfld      int32 Match01/Test1/X14::item
+      IL_0099:  ldloc.0
+      IL_009a:  ldc.i4.6
+      IL_009b:  shl
+      IL_009c:  ldloc.0
+      IL_009d:  ldc.i4.2
+      IL_009e:  shr
+      IL_009f:  add
+      IL_00a0:  add
+      IL_00a1:  add
+      IL_00a2:  stloc.0
+      IL_00a3:  ldloc.0
+      IL_00a4:  ret
+
+      IL_00a5:  ldc.i4.0
+      IL_00a6:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 Match01/Test1::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class Match01/Test1 V_0,
+               int32 V_1,
+               int32 V_2,
+               class Match01/Test1/X11 V_3,
+               class Match01/Test1/X11 V_4,
+               class Match01/Test1/X12 V_5,
+               class Match01/Test1/X12 V_6,
+               class Match01/Test1/X13 V_7,
+               class Match01/Test1/X13 V_8,
+               class Match01/Test1/X14 V_9,
+               class Match01/Test1/X14 V_10)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse    IL_00c9
+
+      IL_0006:  ldarg.1
+      IL_0007:  isinst     Match01/Test1
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  brfalse    IL_00c7
+
+      IL_0013:  ldarg.0
+      IL_0014:  ldfld      int32 Match01/Test1::_tag
+      IL_0019:  stloc.1
+      IL_001a:  ldloc.0
+      IL_001b:  ldfld      int32 Match01/Test1::_tag
+      IL_0020:  stloc.2
+      IL_0021:  ldloc.1
+      IL_0022:  ldloc.2
+      IL_0023:  bne.un     IL_00c5
+
+      IL_0028:  ldarg.0
+      IL_0029:  call       instance int32 Match01/Test1::get_Tag()
+      IL_002e:  switch     ( 
+                            IL_0043,
+                            IL_0062,
+                            IL_0083,
+                            IL_00a4)
+      IL_0043:  ldarg.0
+      IL_0044:  castclass  Match01/Test1/X11
+      IL_0049:  stloc.3
+      IL_004a:  ldloc.0
+      IL_004b:  castclass  Match01/Test1/X11
+      IL_0050:  stloc.s    V_4
+      IL_0052:  ldloc.3
+      IL_0053:  ldfld      int32 Match01/Test1/X11::item
+      IL_0058:  ldloc.s    V_4
+      IL_005a:  ldfld      int32 Match01/Test1/X11::item
+      IL_005f:  ceq
+      IL_0061:  ret
+
+      IL_0062:  ldarg.0
+      IL_0063:  castclass  Match01/Test1/X12
+      IL_0068:  stloc.s    V_5
+      IL_006a:  ldloc.0
+      IL_006b:  castclass  Match01/Test1/X12
+      IL_0070:  stloc.s    V_6
+      IL_0072:  ldloc.s    V_5
+      IL_0074:  ldfld      int32 Match01/Test1/X12::item
+      IL_0079:  ldloc.s    V_6
+      IL_007b:  ldfld      int32 Match01/Test1/X12::item
+      IL_0080:  ceq
+      IL_0082:  ret
+
+      IL_0083:  ldarg.0
+      IL_0084:  castclass  Match01/Test1/X13
+      IL_0089:  stloc.s    V_7
+      IL_008b:  ldloc.0
+      IL_008c:  castclass  Match01/Test1/X13
+      IL_0091:  stloc.s    V_8
+      IL_0093:  ldloc.s    V_7
+      IL_0095:  ldfld      int32 Match01/Test1/X13::item
+      IL_009a:  ldloc.s    V_8
+      IL_009c:  ldfld      int32 Match01/Test1/X13::item
+      IL_00a1:  ceq
+      IL_00a3:  ret
+
+      IL_00a4:  ldarg.0
+      IL_00a5:  castclass  Match01/Test1/X14
+      IL_00aa:  stloc.s    V_9
+      IL_00ac:  ldloc.0
+      IL_00ad:  castclass  Match01/Test1/X14
+      IL_00b2:  stloc.s    V_10
+      IL_00b4:  ldloc.s    V_9
+      IL_00b6:  ldfld      int32 Match01/Test1/X14::item
+      IL_00bb:  ldloc.s    V_10
+      IL_00bd:  ldfld      int32 Match01/Test1/X14::item
+      IL_00c2:  ceq
+      IL_00c4:  ret
+
+      IL_00c5:  ldc.i4.0
+      IL_00c6:  ret
+
+      IL_00c7:  ldc.i4.0
+      IL_00c8:  ret
+
+      IL_00c9:  ldarg.1
+      IL_00ca:  ldnull
+      IL_00cb:  cgt.un
+      IL_00cd:  ldc.i4.0
+      IL_00ce:  ceq
+      IL_00d0:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class Match01/Test1 obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (int32 V_0,
+               int32 V_1,
+               class Match01/Test1/X11 V_2,
+               class Match01/Test1/X11 V_3,
+               class Match01/Test1/X12 V_4,
+               class Match01/Test1/X12 V_5,
+               class Match01/Test1/X13 V_6,
+               class Match01/Test1/X13 V_7,
+               class Match01/Test1/X14 V_8,
+               class Match01/Test1/X14 V_9)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse    IL_00c0
+
+      IL_0006:  ldarg.1
+      IL_0007:  brfalse    IL_00be
+
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      int32 Match01/Test1::_tag
+      IL_0012:  stloc.0
+      IL_0013:  ldarg.1
+      IL_0014:  ldfld      int32 Match01/Test1::_tag
+      IL_0019:  stloc.1
+      IL_001a:  ldloc.0
+      IL_001b:  ldloc.1
+      IL_001c:  bne.un     IL_00bc
+
+      IL_0021:  ldarg.0
+      IL_0022:  call       instance int32 Match01/Test1::get_Tag()
+      IL_0027:  switch     ( 
+                            IL_003c,
+                            IL_0059,
+                            IL_007a,
+                            IL_009b)
+      IL_003c:  ldarg.0
+      IL_003d:  castclass  Match01/Test1/X11
+      IL_0042:  stloc.2
+      IL_0043:  ldarg.1
+      IL_0044:  castclass  Match01/Test1/X11
+      IL_0049:  stloc.3
+      IL_004a:  ldloc.2
+      IL_004b:  ldfld      int32 Match01/Test1/X11::item
+      IL_0050:  ldloc.3
+      IL_0051:  ldfld      int32 Match01/Test1/X11::item
+      IL_0056:  ceq
+      IL_0058:  ret
+
+      IL_0059:  ldarg.0
+      IL_005a:  castclass  Match01/Test1/X12
+      IL_005f:  stloc.s    V_4
+      IL_0061:  ldarg.1
+      IL_0062:  castclass  Match01/Test1/X12
+      IL_0067:  stloc.s    V_5
+      IL_0069:  ldloc.s    V_4
+      IL_006b:  ldfld      int32 Match01/Test1/X12::item
+      IL_0070:  ldloc.s    V_5
+      IL_0072:  ldfld      int32 Match01/Test1/X12::item
+      IL_0077:  ceq
+      IL_0079:  ret
+
+      IL_007a:  ldarg.0
+      IL_007b:  castclass  Match01/Test1/X13
+      IL_0080:  stloc.s    V_6
+      IL_0082:  ldarg.1
+      IL_0083:  castclass  Match01/Test1/X13
+      IL_0088:  stloc.s    V_7
+      IL_008a:  ldloc.s    V_6
+      IL_008c:  ldfld      int32 Match01/Test1/X13::item
+      IL_0091:  ldloc.s    V_7
+      IL_0093:  ldfld      int32 Match01/Test1/X13::item
+      IL_0098:  ceq
+      IL_009a:  ret
+
+      IL_009b:  ldarg.0
+      IL_009c:  castclass  Match01/Test1/X14
+      IL_00a1:  stloc.s    V_8
+      IL_00a3:  ldarg.1
+      IL_00a4:  castclass  Match01/Test1/X14
+      IL_00a9:  stloc.s    V_9
+      IL_00ab:  ldloc.s    V_8
+      IL_00ad:  ldfld      int32 Match01/Test1/X14::item
+      IL_00b2:  ldloc.s    V_9
+      IL_00b4:  ldfld      int32 Match01/Test1/X14::item
+      IL_00b9:  ceq
+      IL_00bb:  ret
+
+      IL_00bc:  ldc.i4.0
+      IL_00bd:  ret
+
+      IL_00be:  ldc.i4.0
+      IL_00bf:  ret
+
+      IL_00c0:  ldarg.1
+      IL_00c1:  ldnull
+      IL_00c2:  cgt.un
+      IL_00c4:  ldc.i4.0
+      IL_00c5:  ceq
+      IL_00c7:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class Match01/Test1 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     Match01/Test1
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool Match01/Test1::Equals(class Match01/Test1)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 Match01/Test1::get_Tag()
+    } 
+    .property instance bool IsX11()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool Match01/Test1::get_IsX11()
+    } 
+    .property instance bool IsX12()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool Match01/Test1::get_IsX12()
+    } 
+    .property instance bool IsX13()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool Match01/Test1::get_IsX13()
+    } 
+    .property instance bool IsX14()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance bool Match01/Test1::get_IsX14()
+    } 
+  } 
+
+  .method public static int32  select1(class Match01/Test1 x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ldarg.0
+    IL_0002:  call       instance int32 Match01/Test1::get_Tag()
+    IL_0007:  switch     ( 
+                          IL_001c,
+                          IL_0028,
+                          IL_002a,
+                          IL_002c)
+    IL_001c:  ldarg.0
+    IL_001d:  castclass  Match01/Test1/X11
+    IL_0022:  ldfld      int32 Match01/Test1/X11::item
+    IL_0027:  ret
+
+    IL_0028:  ldc.i4.2
+    IL_0029:  ret
+
+    IL_002a:  ldc.i4.3
+    IL_002b:  ret
+
+    IL_002c:  ldc.i4.4
+    IL_002d:  ret
+  } 
+
+  .method public static int32  fm(class Match01/Test1 y) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       int32 Match01::select1(class Match01/Test1)
+    IL_0006:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Match01
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping.fs
index 85b40d306f4..abdc6368d11 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open Xunit
 open FSharp.Test
@@ -17,37 +17,85 @@ module ListExpressionStepping =
         |> verifyILBaseline
 
     // SOURCE=ListExpressionSteppingTest1.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ListExpressionSteppingTest1.exe"    # ListExpressionSteppingTest1.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ListExpressionStepping01.fs"|])>]
-    let ``ListExpressionStepping01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ListExpressionStepping01.fs"|])>]
+    let ``ListExpressionStepping01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    // SOURCE=ListExpressionSteppingTest1.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ListExpressionSteppingTest1.exe"    # ListExpressionSteppingTest1.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ListExpressionStepping01.fs"|])>]
+    let ``ListExpressionStepping01_RealInternalSignatureOn_Off`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=ListExpressionSteppingTest2.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ListExpressionSteppingTest2.exe"    # ListExpressionSteppingTest2.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ListExpressionStepping02.fs"|])>]
+    let ``ListExpressionStepping02_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=ListExpressionSteppingTest2.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ListExpressionSteppingTest2.exe"    # ListExpressionSteppingTest2.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ListExpressionStepping02.fs"|])>]
-    let ``ListExpressionStepping02_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ListExpressionStepping02.fs"|])>]
+    let ``ListExpressionStepping02_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=ListExpressionSteppingTest3.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ListExpressionSteppingTest3.exe"    # ListExpressionSteppingTest3.fs 
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ListExpressionStepping03.fs"|])>]
+    let ``ListExpressionStepping03_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=ListExpressionSteppingTest3.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ListExpressionSteppingTest3.exe"    # ListExpressionSteppingTest3.fs 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ListExpressionStepping03.fs"|])>]
-    let ``ListExpressionStepping03_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ListExpressionStepping03.fs"|])>]
+    let ``ListExpressionStepping03_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     // SOURCE=ListExpressionSteppingTest4.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ListExpressionSteppingTest4.exe"    # ListExpressionSteppingTest4.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ListExpressionStepping04.fs"|])>]
-    let ``ListExpressionStepping04_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ListExpressionStepping04.fs"|])>]
+    let ``ListExpressionStepping04_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    // SOURCE=ListExpressionSteppingTest4.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ListExpressionSteppingTest4.exe"    # ListExpressionSteppingTest4.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ListExpressionStepping04.fs"|])>]
+    let ``ListExpressionStepping04_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=ListExpressionSteppingTest5.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ListExpressionSteppingTest5.exe"    # ListExpressionSteppingTest5.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ListExpressionStepping05.fs"|])>]
+    let ``ListExpressionStepping05_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=ListExpressionSteppingTest5.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ListExpressionSteppingTest5.exe"    # ListExpressionSteppingTest5.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ListExpressionStepping05.fs"|])>]
-    let ``ListExpressionStepping05_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ListExpressionStepping05.fs"|])>]
+    let ``ListExpressionStepping05_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=ListExpressionSteppingTest6.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ListExpressionSteppingTest6.exe"    # ListExpressionSteppingTest6.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ListExpressionStepping06.fs"|])>]
+    let ``ListExpressionStepping06_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=ListExpressionSteppingTest6.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ListExpressionSteppingTest6.exe"    # ListExpressionSteppingTest6.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ListExpressionStepping06.fs"|])>]
-    let ``ListExpressionStepping06_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ListExpressionStepping06.fs"|])>]
+    let ``ListExpressionStepping06_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping01.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping01.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping01.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping01.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..379732c096d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping01.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,130 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed ListExpressionSteppingTest1
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public ListExpressionSteppingTest1
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> f0() cil managed
+    {
+      
+      .maxstack  4
+      .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32> V_0)
+      IL_0000:  nop
+      IL_0001:  ldloca.s   V_0
+      IL_0003:  ldc.i4.1
+      IL_0004:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Add(!0)
+      IL_0009:  nop
+      IL_000a:  ldloca.s   V_0
+      IL_000c:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Close()
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest1::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest1::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest1/ListExpressionSteppingTest1::f0()
+      IL_0005:  pop
+      IL_0006:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest1::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest1::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void ListExpressionSteppingTest1/ListExpressionSteppingTest1::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$ListExpressionSteppingTest1
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void ListExpressionSteppingTest1::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping02.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping02.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping02.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping02.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping02.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping02.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..a36fbb087b0
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping02.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,448 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed ListExpressionSteppingTest2
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public ListExpressionSteppingTest2
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 stage #2 at line 18@18'<a>
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<!a,int32>,class [runtime]System.Tuple`2<!a,int32>>
+    {
+      .field static assembly initonly class ListExpressionSteppingTest2/ListExpressionSteppingTest2/'Pipe #1 stage #2 at line 18@18'<!a> @_instance
+      .method assembly specialname rtspecialname instance void  .ctor() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<!a,int32>,class [runtime]System.Tuple`2<!a,int32>>::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance class [runtime]System.Tuple`2<!a,int32> Invoke(class [runtime]System.Tuple`2<!a,int32> tupledArg) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (!a V_0,
+                 int32 V_1)
+        IL_0000:  ldarg.1
+        IL_0001:  call       instance !0 class [runtime]System.Tuple`2<!a,int32>::get_Item1()
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.1
+        IL_0008:  call       instance !1 class [runtime]System.Tuple`2<!a,int32>::get_Item2()
+        IL_000d:  stloc.1
+        IL_000e:  ldloc.0
+        IL_000f:  ldloc.1
+        IL_0010:  ldc.i4.1
+        IL_0011:  add
+        IL_0012:  newobj     instance void class [runtime]System.Tuple`2<!a,int32>::.ctor(!0,
+                                                                                           !1)
+        IL_0017:  ret
+      } 
+
+      .method private specialname rtspecialname static void  .cctor() cil managed
+      {
+        
+        .maxstack  10
+        IL_0000:  newobj     instance void class ListExpressionSteppingTest2/ListExpressionSteppingTest2/'Pipe #1 stage #2 at line 18@18'<!a>::.ctor()
+        IL_0005:  stsfld     class ListExpressionSteppingTest2/ListExpressionSteppingTest2/'Pipe #1 stage #2 at line 18@18'<!0> class ListExpressionSteppingTest2/ListExpressionSteppingTest2/'Pipe #1 stage #2 at line 18@18'<!a>::@_instance
+        IL_000a:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit xs1@19<a>
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<!a,int32>,class [runtime]System.Tuple`2<!a,int32>>
+    {
+      .field static assembly initonly class ListExpressionSteppingTest2/ListExpressionSteppingTest2/xs1@19<!a> @_instance
+      .method assembly specialname rtspecialname instance void  .ctor() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<!a,int32>,class [runtime]System.Tuple`2<!a,int32>>::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance class [runtime]System.Tuple`2<!a,int32> Invoke(class [runtime]System.Tuple`2<!a,int32> tupledArg) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (!a V_0,
+                 int32 V_1)
+        IL_0000:  ldarg.1
+        IL_0001:  call       instance !0 class [runtime]System.Tuple`2<!a,int32>::get_Item1()
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.1
+        IL_0008:  call       instance !1 class [runtime]System.Tuple`2<!a,int32>::get_Item2()
+        IL_000d:  stloc.1
+        IL_000e:  ldloc.0
+        IL_000f:  ldloc.1
+        IL_0010:  ldc.i4.1
+        IL_0011:  add
+        IL_0012:  newobj     instance void class [runtime]System.Tuple`2<!a,int32>::.ctor(!0,
+                                                                                           !1)
+        IL_0017:  ret
+      } 
+
+      .method private specialname rtspecialname static void  .cctor() cil managed
+      {
+        
+        .maxstack  10
+        IL_0000:  newobj     instance void class ListExpressionSteppingTest2/ListExpressionSteppingTest2/xs1@19<!a>::.ctor()
+        IL_0005:  stsfld     class ListExpressionSteppingTest2/ListExpressionSteppingTest2/xs1@19<!0> class ListExpressionSteppingTest2/ListExpressionSteppingTest2/xs1@19<!a>::@_instance
+        IL_000a:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 stage #2 at line 24@24'<a>
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<!a,int32,int32>,class [runtime]System.Tuple`3<!a,int32,int32>>
+    {
+      .field static assembly initonly class ListExpressionSteppingTest2/ListExpressionSteppingTest2/'Pipe #2 stage #2 at line 24@24'<!a> @_instance
+      .method assembly specialname rtspecialname instance void  .ctor() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<!a,int32,int32>,class [runtime]System.Tuple`3<!a,int32,int32>>::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance class [runtime]System.Tuple`3<!a,int32,int32> Invoke(class [runtime]System.Tuple`3<!a,int32,int32> tupledArg) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (!a V_0,
+                 int32 V_1,
+                 int32 V_2)
+        IL_0000:  ldarg.1
+        IL_0001:  call       instance !0 class [runtime]System.Tuple`3<!a,int32,int32>::get_Item1()
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.1
+        IL_0008:  call       instance !1 class [runtime]System.Tuple`3<!a,int32,int32>::get_Item2()
+        IL_000d:  stloc.1
+        IL_000e:  ldarg.1
+        IL_000f:  call       instance !2 class [runtime]System.Tuple`3<!a,int32,int32>::get_Item3()
+        IL_0014:  stloc.2
+        IL_0015:  ldloc.0
+        IL_0016:  ldloc.1
+        IL_0017:  ldc.i4.1
+        IL_0018:  add
+        IL_0019:  ldloc.2
+        IL_001a:  newobj     instance void class [runtime]System.Tuple`3<!a,int32,int32>::.ctor(!0,
+                                                                                                 !1,
+                                                                                                 !2)
+        IL_001f:  ret
+      } 
+
+      .method private specialname rtspecialname static void  .cctor() cil managed
+      {
+        
+        .maxstack  10
+        IL_0000:  newobj     instance void class ListExpressionSteppingTest2/ListExpressionSteppingTest2/'Pipe #2 stage #2 at line 24@24'<!a>::.ctor()
+        IL_0005:  stsfld     class ListExpressionSteppingTest2/ListExpressionSteppingTest2/'Pipe #2 stage #2 at line 24@24'<!0> class ListExpressionSteppingTest2/ListExpressionSteppingTest2/'Pipe #2 stage #2 at line 24@24'<!a>::@_instance
+        IL_000a:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit xs2@25<a>
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<!a,int32,int32>,class [runtime]System.Tuple`3<!a,int32,int32>>
+    {
+      .field static assembly initonly class ListExpressionSteppingTest2/ListExpressionSteppingTest2/xs2@25<!a> @_instance
+      .method assembly specialname rtspecialname instance void  .ctor() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<!a,int32,int32>,class [runtime]System.Tuple`3<!a,int32,int32>>::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance class [runtime]System.Tuple`3<!a,int32,int32> Invoke(class [runtime]System.Tuple`3<!a,int32,int32> tupledArg) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (!a V_0,
+                 int32 V_1,
+                 int32 V_2)
+        IL_0000:  ldarg.1
+        IL_0001:  call       instance !0 class [runtime]System.Tuple`3<!a,int32,int32>::get_Item1()
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.1
+        IL_0008:  call       instance !1 class [runtime]System.Tuple`3<!a,int32,int32>::get_Item2()
+        IL_000d:  stloc.1
+        IL_000e:  ldarg.1
+        IL_000f:  call       instance !2 class [runtime]System.Tuple`3<!a,int32,int32>::get_Item3()
+        IL_0014:  stloc.2
+        IL_0015:  ldloc.0
+        IL_0016:  ldloc.1
+        IL_0017:  ldc.i4.1
+        IL_0018:  add
+        IL_0019:  ldloc.2
+        IL_001a:  newobj     instance void class [runtime]System.Tuple`3<!a,int32,int32>::.ctor(!0,
+                                                                                                 !1,
+                                                                                                 !2)
+        IL_001f:  ret
+      } 
+
+      .method private specialname rtspecialname static void  .cctor() cil managed
+      {
+        
+        .maxstack  10
+        IL_0000:  newobj     instance void class ListExpressionSteppingTest2/ListExpressionSteppingTest2/xs2@25<!a>::.ctor()
+        IL_0005:  stsfld     class ListExpressionSteppingTest2/ListExpressionSteppingTest2/xs2@25<!0> class ListExpressionSteppingTest2/ListExpressionSteppingTest2/xs2@25<!a>::@_instance
+        IL_000a:  ret
+      } 
+
+    } 
+
+    .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> f1() cil managed
+    {
+      
+      .maxstack  4
+      .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32> V_0)
+      IL_0000:  nop
+      IL_0001:  ldstr      "hello"
+      IL_0006:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0010:  pop
+      IL_0011:  ldloca.s   V_0
+      IL_0013:  ldc.i4.1
+      IL_0014:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Add(!0)
+      IL_0019:  nop
+      IL_001a:  ldstr      "goodbye"
+      IL_001f:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_0024:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0029:  pop
+      IL_002a:  ldloca.s   V_0
+      IL_002c:  ldc.i4.2
+      IL_002d:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Add(!0)
+      IL_0032:  nop
+      IL_0033:  ldloca.s   V_0
+      IL_0035:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Close()
+      IL_003a:  ret
+    } 
+
+    .method public static class [runtime]System.Tuple`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<!!a,int32>>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<!!a,int32,int32>>> f2<a>(!!a x) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<!!a,int32>> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a> V_1,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<!!a,int32>> V_3,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<!!a,int32>> V_4,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<!!a,int32,int32>> V_5,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a> V_6,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_7,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_8,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<!!a,int32,int32>> V_9,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<!!a,int32,int32>> V_10)
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.0
+      IL_0002:  ldarg.0
+      IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a>::get_Empty()
+      IL_0008:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_0017:  stloc.1
+      IL_0018:  ldc.i4.0
+      IL_0019:  ldc.i4.1
+      IL_001a:  ldc.i4.2
+      IL_001b:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                       int32,
+                                                                                                                                                                       int32)
+      IL_0020:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::CreateSequence<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0025:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_002a:  stloc.2
+      IL_002b:  ldloc.1
+      IL_002c:  ldloc.2
+      IL_002d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<!!0,!!1>> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::Zip<!!0,int32>(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0>,
+                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!1>)
+      IL_0032:  stloc.3
+      IL_0033:  ldsfld     class ListExpressionSteppingTest2/ListExpressionSteppingTest2/'Pipe #1 stage #2 at line 18@18'<!0> class ListExpressionSteppingTest2/ListExpressionSteppingTest2/'Pipe #1 stage #2 at line 18@18'<!!a>::@_instance
+      IL_0038:  ldloc.3
+      IL_0039:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::Map<class [runtime]System.Tuple`2<!!0,int32>,class [runtime]System.Tuple`2<!!0,int32>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0>)
+      IL_003e:  stloc.s    V_4
+      IL_0040:  ldsfld     class ListExpressionSteppingTest2/ListExpressionSteppingTest2/xs1@19<!0> class ListExpressionSteppingTest2/ListExpressionSteppingTest2/xs1@19<!!a>::@_instance
+      IL_0045:  ldloc.s    V_4
+      IL_0047:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::Map<class [runtime]System.Tuple`2<!!0,int32>,class [runtime]System.Tuple`2<!!0,int32>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0>)
+      IL_004c:  stloc.0
+      IL_004d:  ldarg.0
+      IL_004e:  ldarg.0
+      IL_004f:  ldarg.0
+      IL_0050:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a>::get_Empty()
+      IL_0055:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_005a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_005f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_0064:  stloc.s    V_6
+      IL_0066:  ldc.i4.0
+      IL_0067:  ldc.i4.1
+      IL_0068:  ldc.i4.2
+      IL_0069:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                       int32,
+                                                                                                                                                                       int32)
+      IL_006e:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::CreateSequence<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0073:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0078:  stloc.s    V_7
+      IL_007a:  ldc.i4.0
+      IL_007b:  ldc.i4.1
+      IL_007c:  ldc.i4.2
+      IL_007d:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                       int32,
+                                                                                                                                                                       int32)
+      IL_0082:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::CreateSequence<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0087:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_008c:  stloc.s    V_8
+      IL_008e:  ldloc.s    V_6
+      IL_0090:  ldloc.s    V_7
+      IL_0092:  ldloc.s    V_8
+      IL_0094:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<!!0,!!1,!!2>> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::Zip3<!!0,int32,int32>(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0>,
+                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!1>,
+                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!2>)
+      IL_0099:  stloc.s    V_9
+      IL_009b:  ldsfld     class ListExpressionSteppingTest2/ListExpressionSteppingTest2/'Pipe #2 stage #2 at line 24@24'<!0> class ListExpressionSteppingTest2/ListExpressionSteppingTest2/'Pipe #2 stage #2 at line 24@24'<!!a>::@_instance
+      IL_00a0:  ldloc.s    V_9
+      IL_00a2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::Map<class [runtime]System.Tuple`3<!!0,int32,int32>,class [runtime]System.Tuple`3<!!0,int32,int32>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0>)
+      IL_00a7:  stloc.s    V_10
+      IL_00a9:  ldsfld     class ListExpressionSteppingTest2/ListExpressionSteppingTest2/xs2@25<!0> class ListExpressionSteppingTest2/ListExpressionSteppingTest2/xs2@25<!!a>::@_instance
+      IL_00ae:  ldloc.s    V_10
+      IL_00b0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::Map<class [runtime]System.Tuple`3<!!0,int32,int32>,class [runtime]System.Tuple`3<!!0,int32,int32>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0>)
+      IL_00b5:  stloc.s    V_5
+      IL_00b7:  ldloc.0
+      IL_00b8:  ldloc.s    V_5
+      IL_00ba:  newobj     instance void class [runtime]System.Tuple`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<!!a,int32>>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<!!a,int32,int32>>>::.ctor(!0,
+                                                                                                                                                                                                                                                                                                      !1)
+      IL_00bf:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest2::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest2::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest2/ListExpressionSteppingTest2::f1()
+      IL_0005:  pop
+      IL_0006:  ldc.i4.5
+      IL_0007:  call       class [runtime]System.Tuple`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<!!0,int32>>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<!!0,int32,int32>>> ListExpressionSteppingTest2/ListExpressionSteppingTest2::f2<int32>(!!0)
+      IL_000c:  pop
+      IL_000d:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest2::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest2::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void ListExpressionSteppingTest2/ListExpressionSteppingTest2::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$ListExpressionSteppingTest2
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void ListExpressionSteppingTest2::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping03.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping03.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping03.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping03.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping03.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping03.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..c1a7dfe6890
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping03.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,151 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed ListExpressionSteppingTest3
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public ListExpressionSteppingTest3
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> f2() cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_0,
+               valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32> V_1)
+      IL_0000:  ldc.i4.0
+      IL_0001:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::.ctor(!0)
+      IL_0006:  stloc.0
+      IL_0007:  br.s       IL_0035
+
+      IL_0009:  ldloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+      IL_0010:  ldc.i4.1
+      IL_0011:  add
+      IL_0012:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_contents(!0)
+      IL_0017:  ldstr      "hello"
+      IL_001c:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_0021:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0026:  pop
+      IL_0027:  ldloca.s   V_1
+      IL_0029:  ldloc.0
+      IL_002a:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+      IL_002f:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Add(!0)
+      IL_0034:  nop
+      IL_0035:  ldloc.0
+      IL_0036:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+      IL_003b:  ldc.i4.4
+      IL_003c:  blt.s      IL_0009
+
+      IL_003e:  ldloca.s   V_1
+      IL_0040:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Close()
+      IL_0045:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest3::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest3::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest3/ListExpressionSteppingTest3::f2()
+      IL_0005:  pop
+      IL_0006:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest3::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest3::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void ListExpressionSteppingTest3/ListExpressionSteppingTest3::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$ListExpressionSteppingTest3
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void ListExpressionSteppingTest3::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping04.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping04.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping04.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping04.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping04.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping04.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..cc32818bad8
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping04.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,162 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed ListExpressionSteppingTest4
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public ListExpressionSteppingTest4
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> f3() cil managed
+    {
+      
+      .maxstack  5
+      .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_1,
+               class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_2,
+               int32 V_3)
+      IL_0000:  nop
+      IL_0001:  ldc.i4.0
+      IL_0002:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::.ctor(!0)
+      IL_0007:  stloc.1
+      IL_0008:  ldloc.1
+      IL_0009:  ldloc.1
+      IL_000a:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+      IL_000f:  ldc.i4.1
+      IL_0010:  add
+      IL_0011:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_contents(!0)
+      IL_0016:  ldc.i4.0
+      IL_0017:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::.ctor(!0)
+      IL_001c:  stloc.2
+      IL_001d:  ldloc.2
+      IL_001e:  ldloc.2
+      IL_001f:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+      IL_0024:  ldc.i4.1
+      IL_0025:  add
+      IL_0026:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_contents(!0)
+      IL_002b:  ldloca.s   V_0
+      IL_002d:  ldloc.1
+      IL_002e:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+      IL_0033:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Add(!0)
+      IL_0038:  nop
+      IL_0039:  ldloc.1
+      IL_003a:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+      IL_003f:  ldloc.2
+      IL_0040:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+      IL_0045:  add
+      IL_0046:  stloc.3
+      IL_0047:  ldloca.s   V_0
+      IL_0049:  ldloc.3
+      IL_004a:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Add(!0)
+      IL_004f:  nop
+      IL_0050:  ldloca.s   V_0
+      IL_0052:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Close()
+      IL_0057:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest4::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest4::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest4/ListExpressionSteppingTest4::f3()
+      IL_0005:  pop
+      IL_0006:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest4::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest4::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void ListExpressionSteppingTest4/ListExpressionSteppingTest4::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$ListExpressionSteppingTest4
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void ListExpressionSteppingTest4::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping05.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping05.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping05.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping05.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping05.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping05.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..7ceba50a9c1
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping05.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,182 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed ListExpressionSteppingTest5
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public ListExpressionSteppingTest5
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> f4() cil managed
+    {
+      
+      .maxstack  5
+      .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_2,
+               class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_3,
+               int32 V_4)
+      IL_0000:  nop
+      IL_0001:  ldc.i4.0
+      IL_0002:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::.ctor(!0)
+      IL_0007:  stloc.1
+      .try
+      {
+        IL_0008:  nop
+        IL_0009:  ldc.i4.0
+        IL_000a:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::.ctor(!0)
+        IL_000f:  stloc.3
+        IL_0010:  ldloc.3
+        IL_0011:  ldloc.3
+        IL_0012:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_0017:  ldc.i4.1
+        IL_0018:  add
+        IL_0019:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_contents(!0)
+        IL_001e:  ldloca.s   V_0
+        IL_0020:  ldloc.1
+        IL_0021:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_0026:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Add(!0)
+        IL_002b:  nop
+        IL_002c:  ldloc.1
+        IL_002d:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_0032:  ldloc.3
+        IL_0033:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_0038:  add
+        IL_0039:  stloc.s    V_4
+        IL_003b:  ldloca.s   V_0
+        IL_003d:  ldloc.s    V_4
+        IL_003f:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Add(!0)
+        IL_0044:  nop
+        IL_0045:  ldnull
+        IL_0046:  stloc.2
+        IL_0047:  leave.s    IL_0069
+
+      }  
+      finally
+      {
+        IL_0049:  nop
+        IL_004a:  ldloc.1
+        IL_004b:  ldloc.1
+        IL_004c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_0051:  ldc.i4.1
+        IL_0052:  add
+        IL_0053:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_contents(!0)
+        IL_0058:  ldstr      "done"
+        IL_005d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_0062:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0067:  pop
+        IL_0068:  endfinally
+      }  
+      IL_0069:  ldloc.2
+      IL_006a:  pop
+      IL_006b:  ldloca.s   V_0
+      IL_006d:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Close()
+      IL_0072:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest5::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest5::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest5/ListExpressionSteppingTest5::f4()
+      IL_0005:  pop
+      IL_0006:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest5::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest5::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void ListExpressionSteppingTest5/ListExpressionSteppingTest5::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$ListExpressionSteppingTest5
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void ListExpressionSteppingTest5::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping06.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping06.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping06.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping06.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping06.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping06.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..c3bfc328598
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/ListExpressionStepping/ListExpressionStepping06.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,247 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed ListExpressionSteppingTest6
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public ListExpressionSteppingTest6
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> es@5
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_es() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest6/ListExpressionSteppingTest6::es@5
+      IL_0005:  ret
+    } 
+
+    .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> f7() cil managed
+    {
+      
+      .maxstack  4
+      .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32> V_0,
+               class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_2,
+               int32 V_3,
+               class [runtime]System.IDisposable V_4,
+               class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_5,
+               class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_6,
+               int32 V_7,
+               class [runtime]System.IDisposable V_8)
+      IL_0000:  nop
+      IL_0001:  nop
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest6/ListExpressionSteppingTest6::get_es()
+      IL_0007:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_000c:  stloc.1
+      .try
+      {
+        IL_000d:  br.s       IL_002f
+
+        IL_000f:  ldloc.1
+        IL_0010:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+        IL_0015:  stloc.3
+        IL_0016:  ldstr      "hello"
+        IL_001b:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_0020:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0025:  pop
+        IL_0026:  ldloca.s   V_0
+        IL_0028:  ldloc.3
+        IL_0029:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Add(!0)
+        IL_002e:  nop
+        IL_002f:  ldloc.1
+        IL_0030:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+        IL_0035:  brtrue.s   IL_000f
+
+        IL_0037:  ldnull
+        IL_0038:  stloc.2
+        IL_0039:  leave.s    IL_0050
+
+      }  
+      finally
+      {
+        IL_003b:  ldloc.1
+        IL_003c:  isinst     [runtime]System.IDisposable
+        IL_0041:  stloc.s    V_4
+        IL_0043:  ldloc.s    V_4
+        IL_0045:  brfalse.s  IL_004f
+
+        IL_0047:  ldloc.s    V_4
+        IL_0049:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+        IL_004e:  endfinally
+        IL_004f:  endfinally
+      }  
+      IL_0050:  ldloc.2
+      IL_0051:  pop
+      IL_0052:  nop
+      IL_0053:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest6/ListExpressionSteppingTest6::get_es()
+      IL_0058:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_005d:  stloc.s    V_5
+      .try
+      {
+        IL_005f:  br.s       IL_0084
+
+        IL_0061:  ldloc.s    V_5
+        IL_0063:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+        IL_0068:  stloc.s    V_7
+        IL_006a:  ldstr      "goodbye"
+        IL_006f:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_0074:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0079:  pop
+        IL_007a:  ldloca.s   V_0
+        IL_007c:  ldloc.s    V_7
+        IL_007e:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Add(!0)
+        IL_0083:  nop
+        IL_0084:  ldloc.s    V_5
+        IL_0086:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+        IL_008b:  brtrue.s   IL_0061
+
+        IL_008d:  ldnull
+        IL_008e:  stloc.s    V_6
+        IL_0090:  leave.s    IL_00a8
+
+      }  
+      finally
+      {
+        IL_0092:  ldloc.s    V_5
+        IL_0094:  isinst     [runtime]System.IDisposable
+        IL_0099:  stloc.s    V_8
+        IL_009b:  ldloc.s    V_8
+        IL_009d:  brfalse.s  IL_00a7
+
+        IL_009f:  ldloc.s    V_8
+        IL_00a1:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+        IL_00a6:  endfinally
+        IL_00a7:  endfinally
+      }  
+      IL_00a8:  ldloc.s    V_6
+      IL_00aa:  pop
+      IL_00ab:  ldloca.s   V_0
+      IL_00ad:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Close()
+      IL_00b2:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest6::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest6::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.1
+      IL_0001:  ldc.i4.2
+      IL_0002:  ldc.i4.3
+      IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+      IL_0008:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_0017:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest6/ListExpressionSteppingTest6::es@5
+      IL_001c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest6/ListExpressionSteppingTest6::f7()
+      IL_0021:  pop
+      IL_0022:  ret
+    } 
+
+    .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+            es()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+      .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest6/ListExpressionSteppingTest6::get_es()
+    } 
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest6::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$ListExpressionSteppingTest6::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void ListExpressionSteppingTest6/ListExpressionSteppingTest6::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$ListExpressionSteppingTest6
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void ListExpressionSteppingTest6::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/AbstractClass.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/AbstractClass.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/AbstractClass.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/AbstractClass.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/AbstractClass.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/AbstractClass.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..ea37f2ffd74
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/AbstractClass.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,129 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi serializable nested public X
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.assemblyAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor(int32 i) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldc.i4.1
+      IL_0002:  callvirt   instance void assembly/X::.ctor(int32)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname instance void  .ctor(float32 f) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldc.i4.1
+      IL_0002:  callvirt   instance void assembly/X::.ctor(int32)
+      IL_0007:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_0006:  pop
+    IL_0007:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ArgumentNamesInClosures01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ArgumentNamesInClosures01.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ArgumentNamesInClosures01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ArgumentNamesInClosures01.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ArgumentNamesInClosures01.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ArgumentNamesInClosures01.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..ff66db531a8
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ArgumentNamesInClosures01.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,166 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public C
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public hidebysig instance int32 F(object o) cil managed
+    {
+      
+      .maxstack  3
+      .locals init (class M/C V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  tail.
+      IL_0005:  callvirt   instance int32 [runtime]System.Object::GetHashCode()
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable nested public T
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .class auto ansi serializable sealed nested assembly beforefieldinit get_F@41
+           extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class M/C,int32>
+    {
+      .field static assembly initonly class M/T/get_F@41 @_instance
+      .method assembly specialname rtspecialname instance void  .ctor() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class M/C,int32>::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance int32 Invoke(class M/C i_want_to_see_this_identifier) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.1
+        IL_0001:  tail.
+        IL_0003:  call       int32 M::I(class M/C)
+        IL_0008:  ret
+      } 
+
+      .method private specialname rtspecialname static void  .cctor() cil managed
+      {
+        
+        .maxstack  10
+        IL_0000:  newobj     instance void M/T/get_F@41::.ctor()
+        IL_0005:  stsfld     class M/T/get_F@41 M/T/get_F@41::@_instance
+        IL_000a:  ret
+      } 
+
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class M/C,int32> 
+            get_F() cil managed
+    {
+      
+      .maxstack  3
+      .locals init (class M/T V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  stloc.0
+      IL_0002:  ldsfld     class M/T/get_F@41 M/T/get_F@41::@_instance
+      IL_0007:  ret
+    } 
+
+    .property instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class M/C,int32>
+            F()
+    {
+      .get instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class M/C,int32> M/T::get_F()
+    } 
+  } 
+
+  .method public static int32  I(class M/C i_want_to_see_this_identifier) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldnull
+    IL_0002:  tail.
+    IL_0004:  callvirt   instance int32 M/C::F(object)
+    IL_0009:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/CodeGenRenamings01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/CodeGenRenamings01.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/CodeGenRenamings01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/CodeGenRenamings01.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/CodeGenRenamings01.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/CodeGenRenamings01.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..721b81b0430
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/CodeGenRenamings01.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,657 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname seq1@9
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<int32,int32>>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Tuple`2<int32,int32> current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(int32 pc,
+                                 class [runtime]System.Tuple`2<int32,int32> current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 assembly/seq1@9::pc
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Tuple`2<int32,int32> assembly/seq1@9::current
+      IL_000e:  ldarg.0
+      IL_000f:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<int32,int32>>::.ctor()
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,int32>>& next) cil managed
+    {
+      
+      .maxstack  7
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/seq1@9::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_003b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0051
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0058
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldc.i4.1
+      IL_0027:  stfld      int32 assembly/seq1@9::pc
+      IL_002c:  ldarg.0
+      IL_002d:  ldc.i4.1
+      IL_002e:  ldc.i4.1
+      IL_002f:  newobj     instance void class [runtime]System.Tuple`2<int32,int32>::.ctor(!0,
+                                                                                            !1)
+      IL_0034:  stfld      class [runtime]System.Tuple`2<int32,int32> assembly/seq1@9::current
+      IL_0039:  ldc.i4.1
+      IL_003a:  ret
+
+      IL_003b:  ldarg.0
+      IL_003c:  ldc.i4.2
+      IL_003d:  stfld      int32 assembly/seq1@9::pc
+      IL_0042:  ldarg.0
+      IL_0043:  ldc.i4.2
+      IL_0044:  ldc.i4.2
+      IL_0045:  newobj     instance void class [runtime]System.Tuple`2<int32,int32>::.ctor(!0,
+                                                                                            !1)
+      IL_004a:  stfld      class [runtime]System.Tuple`2<int32,int32> assembly/seq1@9::current
+      IL_004f:  ldc.i4.1
+      IL_0050:  ret
+
+      IL_0051:  ldarg.0
+      IL_0052:  ldc.i4.3
+      IL_0053:  stfld      int32 assembly/seq1@9::pc
+      IL_0058:  ldarg.0
+      IL_0059:  ldnull
+      IL_005a:  stfld      class [runtime]System.Tuple`2<int32,int32> assembly/seq1@9::current
+      IL_005f:  ldc.i4.0
+      IL_0060:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldc.i4.3
+      IL_0002:  stfld      int32 assembly/seq1@9::pc
+      IL_0007:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/seq1@9::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.0
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,int32> get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [runtime]System.Tuple`2<int32,int32> assembly/seq1@9::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<int32,int32>> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ldnull
+      IL_0002:  newobj     instance void assembly/seq1@9::.ctor(int32,
+                                                                          class [runtime]System.Tuple`2<int32,int32>)
+      IL_0007:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> alist@5
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32[] array@6
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<int32> aseq@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<int32,int32>> list1@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,int32>> seq1@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<int32,int32>[] array1@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32[0...,0...] a3@11
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32[0...,0...,0...] array3D@12
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32[0...,0...,0...,0...] array4D@13
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32[] a1@25
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32[] a2@26
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_alist() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::alist@5
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32[] get_array() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::array@6
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<int32> get_aseq() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<int32> assembly::aseq@7
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<int32,int32>> get_list1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<int32,int32>> assembly::list1@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,int32>> get_seq1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,int32>> assembly::seq1@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<int32,int32>[] get_array1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<int32,int32>[] assembly::array1@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32[0...,0...] get_a3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[0...,0...] assembly::a3@11
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32[0...,0...,0...] get_array3D() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[0...,0...,0...] assembly::array3D@12
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32[0...,0...,0...,0...] get_array4D() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[0...,0...,0...,0...] assembly::array4D@13
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32[] get_a1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::a1@25
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32[] get_a2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32[] assembly::a2@26
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    .locals init (int32 V_0,
+             class [runtime]System.Tuple`4<int32,int32,int32,int32> V_1,
+             class [runtime]System.Tuple`4<int32,int32,int32,int32> V_2,
+             int32 V_3,
+             class [runtime]System.Tuple`3<int32,int32,int32> V_4,
+             class [runtime]System.Tuple`3<int32,int32,int32> V_5,
+             int32 V_6,
+             class [runtime]System.Tuple`4<int32,int32,int32,int32> V_7,
+             class [runtime]System.Tuple`4<int32,int32,int32,int32> V_8,
+             int32 V_9)
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.1
+    IL_0002:  ldc.i4.s   10
+    IL_0004:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                     int32,
+                                                                                                                                                                     int32)
+    IL_0009:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::CreateSequence<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_000e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0013:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::alist@5
+    IL_0018:  ldc.i4.3
+    IL_0019:  newarr     [runtime]System.Int32
+    IL_001e:  dup
+    IL_001f:  ldc.i4.0
+    IL_0020:  ldc.i4.1
+    IL_0021:  stelem     [runtime]System.Int32
+    IL_0026:  dup
+    IL_0027:  ldc.i4.1
+    IL_0028:  ldc.i4.2
+    IL_0029:  stelem     [runtime]System.Int32
+    IL_002e:  dup
+    IL_002f:  ldc.i4.2
+    IL_0030:  ldc.i4.3
+    IL_0031:  stelem     [runtime]System.Int32
+    IL_0036:  stsfld     int32[] assembly::array@6
+    IL_003b:  ldc.i4.1
+    IL_003c:  ldc.i4.1
+    IL_003d:  ldc.i4.s   10
+    IL_003f:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                     int32,
+                                                                                                                                                                     int32)
+    IL_0044:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::CreateSequence<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0049:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<int32> assembly::aseq@7
+    IL_004e:  ldc.i4.1
+    IL_004f:  ldc.i4.1
+    IL_0050:  newobj     instance void class [runtime]System.Tuple`2<int32,int32>::.ctor(!0,
+                                                                                          !1)
+    IL_0055:  ldc.i4.2
+    IL_0056:  ldc.i4.2
+    IL_0057:  newobj     instance void class [runtime]System.Tuple`2<int32,int32>::.ctor(!0,
+                                                                                          !1)
+    IL_005c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<int32,int32>>::get_Empty()
+    IL_0061:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<int32,int32>>::Cons(!0,
+                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0066:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<int32,int32>>::Cons(!0,
+                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_006b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<int32,int32>> assembly::list1@8
+    IL_0070:  ldc.i4.0
+    IL_0071:  ldnull
+    IL_0072:  newobj     instance void assembly/seq1@9::.ctor(int32,
+                                                                        class [runtime]System.Tuple`2<int32,int32>)
+    IL_0077:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,int32>> assembly::seq1@9
+    IL_007c:  ldc.i4.2
+    IL_007d:  newarr     class [runtime]System.Tuple`2<int32,int32>
+    IL_0082:  dup
+    IL_0083:  ldc.i4.0
+    IL_0084:  ldc.i4.1
+    IL_0085:  ldc.i4.1
+    IL_0086:  newobj     instance void class [runtime]System.Tuple`2<int32,int32>::.ctor(!0,
+                                                                                          !1)
+    IL_008b:  stelem     class [runtime]System.Tuple`2<int32,int32>
+    IL_0090:  dup
+    IL_0091:  ldc.i4.1
+    IL_0092:  ldc.i4.2
+    IL_0093:  ldc.i4.2
+    IL_0094:  newobj     instance void class [runtime]System.Tuple`2<int32,int32>::.ctor(!0,
+                                                                                          !1)
+    IL_0099:  stelem     class [runtime]System.Tuple`2<int32,int32>
+    IL_009e:  stsfld     class [runtime]System.Tuple`2<int32,int32>[] assembly::array1@10
+    IL_00a3:  ldc.i4.2
+    IL_00a4:  ldc.i4.2
+    IL_00a5:  ldc.i4.0
+    IL_00a6:  call       !!0[0...,0...] [FSharp.Core]Microsoft.FSharp.Collections.Array2DModule::Create<int32>(int32,
+                                                                                                               int32,
+                                                                                                               !!0)
+    IL_00ab:  stsfld     int32[0...,0...] assembly::a3@11
+    IL_00b0:  ldc.i4.3
+    IL_00b1:  ldc.i4.3
+    IL_00b2:  ldc.i4.3
+    IL_00b3:  ldc.i4.0
+    IL_00b4:  call       !!0[0...,0...,0...] [FSharp.Core]Microsoft.FSharp.Collections.Array3DModule::Create<int32>(int32,
+                                                                                                                    int32,
+                                                                                                                    int32,
+                                                                                                                    !!0)
+    IL_00b9:  stsfld     int32[0...,0...,0...] assembly::array3D@12
+    IL_00be:  ldc.i4.4
+    IL_00bf:  ldc.i4.4
+    IL_00c0:  ldc.i4.4
+    IL_00c1:  ldc.i4.4
+    IL_00c2:  ldc.i4.0
+    IL_00c3:  call       !!0[0...,0...,0...,0...] [FSharp.Core]Microsoft.FSharp.Collections.Array4DModule::Create<int32>(int32,
+                                                                                                                         int32,
+                                                                                                                         int32,
+                                                                                                                         int32,
+                                                                                                                         !!0)
+    IL_00c8:  stsfld     int32[0...,0...,0...,0...] assembly::array4D@13
+    IL_00cd:  call       int32[] assembly::get_array()
+    IL_00d2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::OfArray<int32>(!!0[])
+    IL_00d7:  pop
+    IL_00d8:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> assembly::get_aseq()
+    IL_00dd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::OfSeq<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00e2:  pop
+    IL_00e3:  call       class [runtime]System.Tuple`2<int32,int32>[] assembly::get_array1()
+    IL_00e8:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpMap`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Collections.MapModule::OfArray<int32,int32>(class [runtime]System.Tuple`2<!!0,!!1>[])
+    IL_00ed:  pop
+    IL_00ee:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<int32,int32>> assembly::get_list1()
+    IL_00f3:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpMap`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Collections.MapModule::OfList<int32,int32>(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<!!0,!!1>>)
+    IL_00f8:  pop
+    IL_00f9:  call       class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,int32>> assembly::get_seq1()
+    IL_00fe:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpMap`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Collections.MapModule::OfSeq<int32,int32>(class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<!!0,!!1>>)
+    IL_0103:  pop
+    IL_0104:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_alist()
+    IL_0109:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::OfList<int32>(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0>)
+    IL_010e:  stsfld     int32[] assembly::a1@25
+    IL_0113:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> assembly::get_aseq()
+    IL_0118:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::OfSeq<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_011d:  stsfld     int32[] assembly::a2@26
+    IL_0122:  call       int32[] assembly::get_a1()
+    IL_0127:  ldc.i4.0
+    IL_0128:  call       !!0 [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Get<int32>(!!0[],
+                                                                                               int32)
+    IL_012d:  stloc.0
+    IL_012e:  call       int32[] assembly::get_a2()
+    IL_0133:  ldc.i4.0
+    IL_0134:  ldloc.0
+    IL_0135:  call       void [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Set<int32>(!!0[],
+                                                                                                int32,
+                                                                                                !!0)
+    IL_013a:  nop
+    IL_013b:  call       int32[0...,0...] assembly::get_a3()
+    IL_0140:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.Array2DModule::Length1<int32>(!!0[0...,0...])
+    IL_0145:  call       int32[0...,0...] assembly::get_a3()
+    IL_014a:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.Array2DModule::Length2<int32>(!!0[0...,0...])
+    IL_014f:  call       int32[0...,0...] assembly::get_a3()
+    IL_0154:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.Array2DModule::Base1<int32>(!!0[0...,0...])
+    IL_0159:  call       int32[0...,0...] assembly::get_a3()
+    IL_015e:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.Array2DModule::Base2<int32>(!!0[0...,0...])
+    IL_0163:  newobj     instance void class [runtime]System.Tuple`4<int32,int32,int32,int32>::.ctor(!0,
+                                                                                                      !1,
+                                                                                                      !2,
+                                                                                                      !3)
+    IL_0168:  stloc.1
+    IL_0169:  ldloc.1
+    IL_016a:  stloc.2
+    IL_016b:  call       int32[0...,0...] assembly::get_a3()
+    IL_0170:  ldc.i4.0
+    IL_0171:  ldc.i4.0
+    IL_0172:  call       !!0 [FSharp.Core]Microsoft.FSharp.Collections.Array2DModule::Get<int32>(!!0[0...,0...],
+                                                                                                 int32,
+                                                                                                 int32)
+    IL_0177:  stloc.3
+    IL_0178:  call       int32[0...,0...] assembly::get_a3()
+    IL_017d:  ldc.i4.0
+    IL_017e:  ldc.i4.0
+    IL_017f:  ldloc.3
+    IL_0180:  call       void [FSharp.Core]Microsoft.FSharp.Collections.Array2DModule::Set<int32>(!!0[0...,0...],
+                                                                                                  int32,
+                                                                                                  int32,
+                                                                                                  !!0)
+    IL_0185:  nop
+    IL_0186:  call       int32[0...,0...,0...] assembly::get_array3D()
+    IL_018b:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.Array3DModule::Length1<int32>(!!0[0...,0...,0...])
+    IL_0190:  call       int32[0...,0...,0...] assembly::get_array3D()
+    IL_0195:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.Array3DModule::Length2<int32>(!!0[0...,0...,0...])
+    IL_019a:  call       int32[0...,0...,0...] assembly::get_array3D()
+    IL_019f:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.Array3DModule::Length3<int32>(!!0[0...,0...,0...])
+    IL_01a4:  newobj     instance void class [runtime]System.Tuple`3<int32,int32,int32>::.ctor(!0,
+                                                                                                !1,
+                                                                                                !2)
+    IL_01a9:  stloc.s    V_4
+    IL_01ab:  ldloc.s    V_4
+    IL_01ad:  stloc.s    V_5
+    IL_01af:  call       int32[0...,0...,0...] assembly::get_array3D()
+    IL_01b4:  ldc.i4.0
+    IL_01b5:  ldc.i4.0
+    IL_01b6:  ldc.i4.0
+    IL_01b7:  call       !!0 [FSharp.Core]Microsoft.FSharp.Collections.Array3DModule::Get<int32>(!!0[0...,0...,0...],
+                                                                                                 int32,
+                                                                                                 int32,
+                                                                                                 int32)
+    IL_01bc:  stloc.s    V_6
+    IL_01be:  call       int32[0...,0...,0...] assembly::get_array3D()
+    IL_01c3:  ldc.i4.0
+    IL_01c4:  ldc.i4.0
+    IL_01c5:  ldc.i4.0
+    IL_01c6:  ldloc.s    V_6
+    IL_01c8:  call       void [FSharp.Core]Microsoft.FSharp.Collections.Array3DModule::Set<int32>(!!0[0...,0...,0...],
+                                                                                                  int32,
+                                                                                                  int32,
+                                                                                                  int32,
+                                                                                                  !!0)
+    IL_01cd:  nop
+    IL_01ce:  call       int32[0...,0...,0...,0...] assembly::get_array4D()
+    IL_01d3:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.Array4DModule::Length1<int32>(!!0[0...,0...,0...,0...])
+    IL_01d8:  call       int32[0...,0...,0...,0...] assembly::get_array4D()
+    IL_01dd:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.Array4DModule::Length2<int32>(!!0[0...,0...,0...,0...])
+    IL_01e2:  call       int32[0...,0...,0...,0...] assembly::get_array4D()
+    IL_01e7:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.Array4DModule::Length3<int32>(!!0[0...,0...,0...,0...])
+    IL_01ec:  call       int32[0...,0...,0...,0...] assembly::get_array4D()
+    IL_01f1:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.Array4DModule::Length4<int32>(!!0[0...,0...,0...,0...])
+    IL_01f6:  newobj     instance void class [runtime]System.Tuple`4<int32,int32,int32,int32>::.ctor(!0,
+                                                                                                      !1,
+                                                                                                      !2,
+                                                                                                      !3)
+    IL_01fb:  stloc.s    V_7
+    IL_01fd:  ldloc.s    V_7
+    IL_01ff:  stloc.s    V_8
+    IL_0201:  call       int32[0...,0...,0...,0...] assembly::get_array4D()
+    IL_0206:  ldc.i4.0
+    IL_0207:  ldc.i4.0
+    IL_0208:  ldc.i4.0
+    IL_0209:  ldc.i4.0
+    IL_020a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Collections.Array4DModule::Get<int32>(!!0[0...,0...,0...,0...],
+                                                                                                 int32,
+                                                                                                 int32,
+                                                                                                 int32,
+                                                                                                 int32)
+    IL_020f:  stloc.s    V_9
+    IL_0211:  call       int32[0...,0...,0...,0...] assembly::get_array4D()
+    IL_0216:  ldc.i4.0
+    IL_0217:  ldc.i4.0
+    IL_0218:  ldc.i4.0
+    IL_0219:  ldc.i4.0
+    IL_021a:  ldloc.s    V_9
+    IL_021c:  call       void [FSharp.Core]Microsoft.FSharp.Collections.Array4DModule::Set<int32>(!!0[0...,0...,0...,0...],
+                                                                                                  int32,
+                                                                                                  int32,
+                                                                                                  int32,
+                                                                                                  int32,
+                                                                                                  !!0)
+    IL_0221:  nop
+    IL_0222:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          alist()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_alist()
+  } 
+  .property int32[] 'array'()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_array()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<int32>
+          aseq()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<int32> assembly::get_aseq()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<int32,int32>>
+          list1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<int32,int32>> assembly::get_list1()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,int32>>
+          seq1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,int32>> assembly::get_seq1()
+  } 
+  .property class [runtime]System.Tuple`2<int32,int32>[]
+          array1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<int32,int32>[] assembly::get_array1()
+  } 
+  .property int32[0...,0...] a3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[0...,0...] assembly::get_a3()
+  } 
+  .property int32[0...,0...,0...] array3D()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[0...,0...,0...] assembly::get_array3D()
+  } 
+  .property int32[0...,0...,0...,0...] array4D()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[0...,0...,0...,0...] assembly::get_array4D()
+  } 
+  .property int32[] a1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_a1()
+  } 
+  .property int32[] a2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32[] assembly::get_a2()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/CustomAttributeGenericParameter01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/CustomAttributeGenericParameter01.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/CustomAttributeGenericParameter01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/CustomAttributeGenericParameter01.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/CustomAttributeGenericParameter01.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/CustomAttributeGenericParameter01.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..6c8fac9faa7
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/CustomAttributeGenericParameter01.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,101 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed M
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static !!T  f<T>(!!T x) cil managed
+  {
+    .param type T 
+      .custom instance void [runtime]System.CLSCompliantAttribute::.ctor(bool) = ( 01 00 01 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$M::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$M::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_0006:  pop
+    IL_0007:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$M
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void M::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Decimal01.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Decimal01.fs.RealInternalSignatureOff.il.net472.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Decimal01.fs.il.net472.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Decimal01.fs.RealInternalSignatureOff.il.net472.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Decimal01.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Decimal01.fs.RealInternalSignatureOff.il.netcore.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Decimal01.fs.il.netcore.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Decimal01.fs.RealInternalSignatureOff.il.netcore.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Decimal01.fs.RealInternalSignatureOn.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Decimal01.fs.RealInternalSignatureOn.il.net472.bsl
new file mode 100644
index 00000000000..b4095924a48
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Decimal01.fs.RealInternalSignatureOn.il.net472.bsl
@@ -0,0 +1,104 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.s   12
+    IL_0002:  ldc.i4.0
+    IL_0003:  ldc.i4.0
+    IL_0004:  ldc.i4.0
+    IL_0005:  ldc.i4.1
+    IL_0006:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Decimal01.fs.RealInternalSignatureOn.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Decimal01.fs.RealInternalSignatureOn.il.netcore.bsl
new file mode 100644
index 00000000000..3af00969290
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Decimal01.fs.RealInternalSignatureOn.il.netcore.bsl
@@ -0,0 +1,104 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.s   12
+    IL_0002:  ldc.i4.0
+    IL_0003:  ldc.i4.0
+    IL_0004:  ldc.i4.0
+    IL_0005:  ldc.i4.1
+    IL_0006:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/EntryPoint01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/EntryPoint01.RealInternalSignatureOff.fs.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/EntryPoint01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/EntryPoint01.RealInternalSignatureOff.fs.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/EntryPoint01.RealInternalSignatureOn.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/EntryPoint01.RealInternalSignatureOn.fs.il.bsl
new file mode 100644
index 00000000000..237cfc0ea3f
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/EntryPoint01.RealInternalSignatureOn.fs.il.bsl
@@ -0,0 +1,114 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public specialname static int32 
+          get_static_initializer() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.s   10
+    IL_0002:  ret
+  } 
+
+  .method public static int32  main(string[] argsz) cil managed
+  {
+    .entrypoint
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.EntryPointAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  nop
+    IL_000d:  nop
+    IL_000e:  call       int32 assembly::get_static_initializer()
+    IL_0013:  ldc.i4.s   10
+    IL_0015:  bne.un.s   IL_001b
+
+    IL_0017:  ldc.i4.0
+    IL_0018:  nop
+    IL_0019:  br.s       IL_001d
+
+    IL_001b:  ldc.i4.1
+    IL_001c:  nop
+    IL_001d:  tail.
+    IL_001f:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<int32>(int32)
+    IL_0024:  ret
+  } 
+
+  .property int32 static_initializer()
+  {
+    .get int32 assembly::get_static_initializer()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static 
+          void  .cctor() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (int32 V_0)
+    IL_0000:  call       int32 assembly::get_static_initializer()
+    IL_0005:  stloc.0
+    IL_0006:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/EntryPoint01.fs.RealInternalSignatureOff.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/EntryPoint01.fs.RealInternalSignatureOff.il.bsl
new file mode 100644
index 00000000000..0ea905abd6f
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/EntryPoint01.fs.RealInternalSignatureOff.il.bsl
@@ -0,0 +1,112 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public specialname static int32 get_static_initializer() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.s   10
+    IL_0002:  ret
+  } 
+
+  .method public static int32  main(string[] argsz) cil managed
+  {
+    .entrypoint
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.EntryPointAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  nop
+    IL_000d:  nop
+    IL_000e:  call       int32 assembly::get_static_initializer()
+    IL_0013:  ldc.i4.s   10
+    IL_0015:  bne.un.s   IL_001b
+
+    IL_0017:  ldc.i4.0
+    IL_0018:  nop
+    IL_0019:  br.s       IL_001d
+
+    IL_001b:  ldc.i4.1
+    IL_001c:  nop
+    IL_001d:  tail.
+    IL_001f:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<int32>(int32)
+    IL_0024:  ret
+  } 
+
+  .property int32 static_initializer()
+  {
+    .get int32 assembly::get_static_initializer()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (int32 V_0)
+    IL_0000:  call       int32 assembly::get_static_initializer()
+    IL_0005:  stloc.0
+    IL_0006:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/EntryPoint01.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/EntryPoint01.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..f3df30fd7af
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/EntryPoint01.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,94 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public specialname static int32 get_static_initializer() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.s   10
+    IL_0002:  ret
+  } 
+
+  .method public static int32  main(string[] argsz) cil managed
+  {
+    .entrypoint
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.EntryPointAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  nop
+    IL_0002:  call       int32 assembly::get_static_initializer()
+    IL_0007:  ldc.i4.s   10
+    IL_0009:  bne.un.s   IL_000f
+
+    IL_000b:  ldc.i4.0
+    IL_000c:  nop
+    IL_000d:  br.s       IL_0011
+
+    IL_000f:  ldc.i4.1
+    IL_0010:  nop
+    IL_0011:  tail.
+    IL_0013:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<int32>(int32)
+    IL_0018:  ret
+  } 
+
+  .property int32 static_initializer()
+  {
+    .get int32 assembly::get_static_initializer()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop01.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop01.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop01.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop01.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..214395fe6ad
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop01.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,122 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2)
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.1
+    IL_0002:  ldc.i4.3
+    IL_0003:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                     int32,
+                                                                                                                                                                     int32)
+    IL_0008:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Core.Operators::CreateSequence<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0012:  stloc.0
+    IL_0013:  ldloc.0
+    IL_0014:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0019:  stloc.1
+    IL_001a:  br.s       IL_0042
+
+    IL_001c:  ldloc.0
+    IL_001d:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0022:  stloc.2
+    IL_0023:  ldstr      "%A"
+    IL_0028:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_002d:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0032:  ldloc.2
+    IL_0033:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0038:  pop
+    IL_0039:  ldloc.1
+    IL_003a:  stloc.0
+    IL_003b:  ldloc.0
+    IL_003c:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0041:  stloc.1
+    IL_0042:  ldloc.1
+    IL_0043:  brtrue.s   IL_001c
+
+    IL_0045:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop02.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop02.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop02.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop02.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop02.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop02.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..6297992ad5f
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop02.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,109 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0)
+    IL_0000:  ldc.i4.1
+    IL_0001:  stloc.0
+    IL_0002:  br.s       IL_001e
+
+    IL_0004:  ldstr      "%A"
+    IL_0009:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_000e:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0013:  ldloc.0
+    IL_0014:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0019:  pop
+    IL_001a:  ldloc.0
+    IL_001b:  ldc.i4.1
+    IL_001c:  add
+    IL_001d:  stloc.0
+    IL_001e:  ldloc.0
+    IL_001f:  ldc.i4.1
+    IL_0020:  ldc.i4.3
+    IL_0021:  add
+    IL_0022:  blt.s      IL_0004
+
+    IL_0024:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop03.fs.RealInternalSignatureOff.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop03.fs.RealInternalSignatureOff.il.net472.bsl
new file mode 100644
index 00000000000..35835161848
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop03.fs.RealInternalSignatureOff.il.net472.bsl
@@ -0,0 +1,173 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public specialname static class [runtime]System.Collections.Generic.List`1<int32> get_ra() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.List`1<int32> '<StartupCode$assembly>'.$assembly::ra@5
+    IL_0005:  ret
+  } 
+
+  .method public static void  test1() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             class [runtime]System.Collections.Generic.List`1<int32> V_2,
+             valuetype [runtime]System.Collections.Generic.List`1/Enumerator<int32> V_3,
+             int32 V_4)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.1
+    IL_0004:  br.s       IL_003f
+
+    IL_0006:  call       class [runtime]System.Collections.Generic.List`1<int32> assembly::get_ra()
+    IL_000b:  stloc.2
+    IL_000c:  ldloc.2
+    IL_000d:  callvirt   instance valuetype [runtime]System.Collections.Generic.List`1/Enumerator<!0> class [runtime]System.Collections.Generic.List`1<int32>::GetEnumerator()
+    IL_0012:  stloc.3
+    .try
+    {
+      IL_0013:  br.s       IL_0022
+
+      IL_0015:  ldloca.s   V_3
+      IL_0017:  call       instance !0 valuetype [runtime]System.Collections.Generic.List`1/Enumerator<int32>::get_Current()
+      IL_001c:  stloc.s    V_4
+      IL_001e:  ldloc.0
+      IL_001f:  ldc.i4.1
+      IL_0020:  add
+      IL_0021:  stloc.0
+      IL_0022:  ldloca.s   V_3
+      IL_0024:  call       instance bool valuetype [runtime]System.Collections.Generic.List`1/Enumerator<int32>::MoveNext()
+      IL_0029:  brtrue.s   IL_0015
+
+      IL_002b:  leave.s    IL_003b
+
+    }  
+    finally
+    {
+      IL_002d:  ldloca.s   V_3
+      IL_002f:  constrained. valuetype [runtime]System.Collections.Generic.List`1/Enumerator<int32>
+      IL_0035:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_003a:  endfinally
+    }  
+    IL_003b:  ldloc.1
+    IL_003c:  ldc.i4.1
+    IL_003d:  add
+    IL_003e:  stloc.1
+    IL_003f:  ldloc.1
+    IL_0040:  ldc.i4.1
+    IL_0041:  ldc.i4     0x989680
+    IL_0046:  add
+    IL_0047:  blt.s      IL_0006
+
+    IL_0049:  ldstr      "z = %d"
+    IL_004e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_0053:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0058:  ldloc.0
+    IL_0059:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_005e:  pop
+    IL_005f:  ret
+  } 
+
+  .property class [runtime]System.Collections.Generic.List`1<int32>
+          ra()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.List`1<int32> assembly::get_ra()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly class [runtime]System.Collections.Generic.List`1<int32> ra@5
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  5
+    .locals init (class [runtime]System.Collections.Generic.List`1<int32> V_0,
+             int32 V_1)
+    IL_0000:  ldc.i4.s   100
+    IL_0002:  newobj     instance void class [runtime]System.Collections.Generic.List`1<int32>::.ctor(int32)
+    IL_0007:  dup
+    IL_0008:  stsfld     class [runtime]System.Collections.Generic.List`1<int32> '<StartupCode$assembly>'.$assembly::ra@5
+    IL_000d:  stloc.0
+    IL_000e:  ldc.i4.0
+    IL_000f:  stloc.1
+    IL_0010:  br.s       IL_0021
+
+    IL_0012:  call       class [runtime]System.Collections.Generic.List`1<int32> assembly::get_ra()
+    IL_0017:  ldloc.1
+    IL_0018:  callvirt   instance void class [runtime]System.Collections.Generic.List`1<int32>::Add(!0)
+    IL_001d:  ldloc.1
+    IL_001e:  ldc.i4.1
+    IL_001f:  add
+    IL_0020:  stloc.1
+    IL_0021:  ldloc.1
+    IL_0022:  ldc.i4.1
+    IL_0023:  ldc.i4.s   100
+    IL_0025:  add
+    IL_0026:  blt.s      IL_0012
+
+    IL_0028:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop03.fs.RealInternalSignatureOff.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop03.fs.RealInternalSignatureOff.il.netcore.bsl
new file mode 100644
index 00000000000..ca21ccfd0c9
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop03.fs.RealInternalSignatureOff.il.netcore.bsl
@@ -0,0 +1,178 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern System.Collections
+{
+  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         
+  .ver 8:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public specialname static class [System.Collections]System.Collections.Generic.List`1<int32> get_ra() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [System.Collections]System.Collections.Generic.List`1<int32> '<StartupCode$assembly>'.$assembly::ra@5
+    IL_0005:  ret
+  } 
+
+  .method public static void  test1() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             class [System.Collections]System.Collections.Generic.List`1<int32> V_2,
+             valuetype [System.Collections]System.Collections.Generic.List`1/Enumerator<int32> V_3,
+             int32 V_4)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.1
+    IL_0004:  br.s       IL_003f
+
+    IL_0006:  call       class [System.Collections]System.Collections.Generic.List`1<int32> assembly::get_ra()
+    IL_000b:  stloc.2
+    IL_000c:  ldloc.2
+    IL_000d:  callvirt   instance valuetype [System.Collections]System.Collections.Generic.List`1/Enumerator<!0> class [System.Collections]System.Collections.Generic.List`1<int32>::GetEnumerator()
+    IL_0012:  stloc.3
+    .try
+    {
+      IL_0013:  br.s       IL_0022
+
+      IL_0015:  ldloca.s   V_3
+      IL_0017:  call       instance !0 valuetype [System.Collections]System.Collections.Generic.List`1/Enumerator<int32>::get_Current()
+      IL_001c:  stloc.s    V_4
+      IL_001e:  ldloc.0
+      IL_001f:  ldc.i4.1
+      IL_0020:  add
+      IL_0021:  stloc.0
+      IL_0022:  ldloca.s   V_3
+      IL_0024:  call       instance bool valuetype [System.Collections]System.Collections.Generic.List`1/Enumerator<int32>::MoveNext()
+      IL_0029:  brtrue.s   IL_0015
+
+      IL_002b:  leave.s    IL_003b
+
+    }  
+    finally
+    {
+      IL_002d:  ldloca.s   V_3
+      IL_002f:  constrained. valuetype [System.Collections]System.Collections.Generic.List`1/Enumerator<int32>
+      IL_0035:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_003a:  endfinally
+    }  
+    IL_003b:  ldloc.1
+    IL_003c:  ldc.i4.1
+    IL_003d:  add
+    IL_003e:  stloc.1
+    IL_003f:  ldloc.1
+    IL_0040:  ldc.i4.1
+    IL_0041:  ldc.i4     0x989680
+    IL_0046:  add
+    IL_0047:  blt.s      IL_0006
+
+    IL_0049:  ldstr      "z = %d"
+    IL_004e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_0053:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0058:  ldloc.0
+    IL_0059:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_005e:  pop
+    IL_005f:  ret
+  } 
+
+  .property class [System.Collections]System.Collections.Generic.List`1<int32>
+          ra()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [System.Collections]System.Collections.Generic.List`1<int32> assembly::get_ra()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly class [System.Collections]System.Collections.Generic.List`1<int32> ra@5
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  5
+    .locals init (class [System.Collections]System.Collections.Generic.List`1<int32> V_0,
+             int32 V_1)
+    IL_0000:  ldc.i4.s   100
+    IL_0002:  newobj     instance void class [System.Collections]System.Collections.Generic.List`1<int32>::.ctor(int32)
+    IL_0007:  dup
+    IL_0008:  stsfld     class [System.Collections]System.Collections.Generic.List`1<int32> '<StartupCode$assembly>'.$assembly::ra@5
+    IL_000d:  stloc.0
+    IL_000e:  ldc.i4.0
+    IL_000f:  stloc.1
+    IL_0010:  br.s       IL_0021
+
+    IL_0012:  call       class [System.Collections]System.Collections.Generic.List`1<int32> assembly::get_ra()
+    IL_0017:  ldloc.1
+    IL_0018:  callvirt   instance void class [System.Collections]System.Collections.Generic.List`1<int32>::Add(!0)
+    IL_001d:  ldloc.1
+    IL_001e:  ldc.i4.1
+    IL_001f:  add
+    IL_0020:  stloc.1
+    IL_0021:  ldloc.1
+    IL_0022:  ldc.i4.1
+    IL_0023:  ldc.i4.s   100
+    IL_0025:  add
+    IL_0026:  blt.s      IL_0012
+
+    IL_0028:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop03.fs.RealInternalSignatureOn.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop03.fs.RealInternalSignatureOn.il.net472.bsl
new file mode 100644
index 00000000000..89116dd2c87
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop03.fs.RealInternalSignatureOn.il.net472.bsl
@@ -0,0 +1,189 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.List`1<int32> ra@5
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [runtime]System.Collections.Generic.List`1<int32> get_ra() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.List`1<int32> assembly::ra@5
+    IL_0005:  ret
+  } 
+
+  .method public static void  test1() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             class [runtime]System.Collections.Generic.List`1<int32> V_2,
+             valuetype [runtime]System.Collections.Generic.List`1/Enumerator<int32> V_3,
+             int32 V_4)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.1
+    IL_0004:  br.s       IL_003f
+
+    IL_0006:  call       class [runtime]System.Collections.Generic.List`1<int32> assembly::get_ra()
+    IL_000b:  stloc.2
+    IL_000c:  ldloc.2
+    IL_000d:  callvirt   instance valuetype [runtime]System.Collections.Generic.List`1/Enumerator<!0> class [runtime]System.Collections.Generic.List`1<int32>::GetEnumerator()
+    IL_0012:  stloc.3
+    .try
+    {
+      IL_0013:  br.s       IL_0022
+
+      IL_0015:  ldloca.s   V_3
+      IL_0017:  call       instance !0 valuetype [runtime]System.Collections.Generic.List`1/Enumerator<int32>::get_Current()
+      IL_001c:  stloc.s    V_4
+      IL_001e:  ldloc.0
+      IL_001f:  ldc.i4.1
+      IL_0020:  add
+      IL_0021:  stloc.0
+      IL_0022:  ldloca.s   V_3
+      IL_0024:  call       instance bool valuetype [runtime]System.Collections.Generic.List`1/Enumerator<int32>::MoveNext()
+      IL_0029:  brtrue.s   IL_0015
+
+      IL_002b:  leave.s    IL_003b
+
+    }  
+    finally
+    {
+      IL_002d:  ldloca.s   V_3
+      IL_002f:  constrained. valuetype [runtime]System.Collections.Generic.List`1/Enumerator<int32>
+      IL_0035:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_003a:  endfinally
+    }  
+    IL_003b:  ldloc.1
+    IL_003c:  ldc.i4.1
+    IL_003d:  add
+    IL_003e:  stloc.1
+    IL_003f:  ldloc.1
+    IL_0040:  ldc.i4.1
+    IL_0041:  ldc.i4     0x989680
+    IL_0046:  add
+    IL_0047:  blt.s      IL_0006
+
+    IL_0049:  ldstr      "z = %d"
+    IL_004e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_0053:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0058:  ldloc.0
+    IL_0059:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_005e:  pop
+    IL_005f:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0)
+    IL_0000:  ldc.i4.s   100
+    IL_0002:  newobj     instance void class [runtime]System.Collections.Generic.List`1<int32>::.ctor(int32)
+    IL_0007:  stsfld     class [runtime]System.Collections.Generic.List`1<int32> assembly::ra@5
+    IL_000c:  ldc.i4.0
+    IL_000d:  stloc.0
+    IL_000e:  br.s       IL_001f
+
+    IL_0010:  call       class [runtime]System.Collections.Generic.List`1<int32> assembly::get_ra()
+    IL_0015:  ldloc.0
+    IL_0016:  callvirt   instance void class [runtime]System.Collections.Generic.List`1<int32>::Add(!0)
+    IL_001b:  ldloc.0
+    IL_001c:  ldc.i4.1
+    IL_001d:  add
+    IL_001e:  stloc.0
+    IL_001f:  ldloc.0
+    IL_0020:  ldc.i4.1
+    IL_0021:  ldc.i4.s   100
+    IL_0023:  add
+    IL_0024:  blt.s      IL_0010
+
+    IL_0026:  ret
+  } 
+
+  .property class [runtime]System.Collections.Generic.List`1<int32>
+          ra()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.List`1<int32> assembly::get_ra()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop03.fs.RealInternalSignatureOn.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop03.fs.RealInternalSignatureOn.il.netcore.bsl
new file mode 100644
index 00000000000..9c2772ab7b5
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ForLoop03.fs.RealInternalSignatureOn.il.netcore.bsl
@@ -0,0 +1,194 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern System.Collections
+{
+  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         
+  .ver 8:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly class [System.Collections]System.Collections.Generic.List`1<int32> ra@5
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [System.Collections]System.Collections.Generic.List`1<int32> get_ra() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [System.Collections]System.Collections.Generic.List`1<int32> assembly::ra@5
+    IL_0005:  ret
+  } 
+
+  .method public static void  test1() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1,
+             class [System.Collections]System.Collections.Generic.List`1<int32> V_2,
+             valuetype [System.Collections]System.Collections.Generic.List`1/Enumerator<int32> V_3,
+             int32 V_4)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.1
+    IL_0004:  br.s       IL_003f
+
+    IL_0006:  call       class [System.Collections]System.Collections.Generic.List`1<int32> assembly::get_ra()
+    IL_000b:  stloc.2
+    IL_000c:  ldloc.2
+    IL_000d:  callvirt   instance valuetype [System.Collections]System.Collections.Generic.List`1/Enumerator<!0> class [System.Collections]System.Collections.Generic.List`1<int32>::GetEnumerator()
+    IL_0012:  stloc.3
+    .try
+    {
+      IL_0013:  br.s       IL_0022
+
+      IL_0015:  ldloca.s   V_3
+      IL_0017:  call       instance !0 valuetype [System.Collections]System.Collections.Generic.List`1/Enumerator<int32>::get_Current()
+      IL_001c:  stloc.s    V_4
+      IL_001e:  ldloc.0
+      IL_001f:  ldc.i4.1
+      IL_0020:  add
+      IL_0021:  stloc.0
+      IL_0022:  ldloca.s   V_3
+      IL_0024:  call       instance bool valuetype [System.Collections]System.Collections.Generic.List`1/Enumerator<int32>::MoveNext()
+      IL_0029:  brtrue.s   IL_0015
+
+      IL_002b:  leave.s    IL_003b
+
+    }  
+    finally
+    {
+      IL_002d:  ldloca.s   V_3
+      IL_002f:  constrained. valuetype [System.Collections]System.Collections.Generic.List`1/Enumerator<int32>
+      IL_0035:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_003a:  endfinally
+    }  
+    IL_003b:  ldloc.1
+    IL_003c:  ldc.i4.1
+    IL_003d:  add
+    IL_003e:  stloc.1
+    IL_003f:  ldloc.1
+    IL_0040:  ldc.i4.1
+    IL_0041:  ldc.i4     0x989680
+    IL_0046:  add
+    IL_0047:  blt.s      IL_0006
+
+    IL_0049:  ldstr      "z = %d"
+    IL_004e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::.ctor(string)
+    IL_0053:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0058:  ldloc.0
+    IL_0059:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_005e:  pop
+    IL_005f:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0)
+    IL_0000:  ldc.i4.s   100
+    IL_0002:  newobj     instance void class [System.Collections]System.Collections.Generic.List`1<int32>::.ctor(int32)
+    IL_0007:  stsfld     class [System.Collections]System.Collections.Generic.List`1<int32> assembly::ra@5
+    IL_000c:  ldc.i4.0
+    IL_000d:  stloc.0
+    IL_000e:  br.s       IL_001f
+
+    IL_0010:  call       class [System.Collections]System.Collections.Generic.List`1<int32> assembly::get_ra()
+    IL_0015:  ldloc.0
+    IL_0016:  callvirt   instance void class [System.Collections]System.Collections.Generic.List`1<int32>::Add(!0)
+    IL_001b:  ldloc.0
+    IL_001c:  ldc.i4.1
+    IL_001d:  add
+    IL_001e:  stloc.0
+    IL_001f:  ldloc.0
+    IL_0020:  ldc.i4.1
+    IL_0021:  ldc.i4.s   100
+    IL_0023:  add
+    IL_0024:  blt.s      IL_0010
+
+    IL_0026:  ret
+  } 
+
+  .property class [System.Collections]System.Collections.Generic.List`1<int32>
+          ra()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [System.Collections]System.Collections.Generic.List`1<int32> assembly::get_ra()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/GeneralizationOnUnions01.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/GeneralizationOnUnions01.fs.RealInternalSignatureOff.il.net472.bsl
similarity index 93%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/GeneralizationOnUnions01.fs.il.net472.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/GeneralizationOnUnions01.fs.RealInternalSignatureOff.il.net472.bsl
index f0bf8062180..dc9cc7f2ed7 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/GeneralizationOnUnions01.fs.il.net472.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/GeneralizationOnUnions01.fs.RealInternalSignatureOff.il.net472.bsl
@@ -58,8 +58,7 @@
     .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-    .method private specialname rtspecialname static 
-            void  .cctor() cil managed
+    .method private specialname rtspecialname static void  .cctor() cil managed
     {
       
       .maxstack  8
@@ -68,8 +67,7 @@
       IL_000a:  ret
     } 
 
-    .method assembly specialname rtspecialname 
-            instance void  .ctor() cil managed
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
     {
       .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
                                                                                               class [runtime]System.Type) = ( 01 00 E0 07 00 00 1F 47 65 6E 65 72 61 6C 69 7A   
@@ -84,8 +82,7 @@
       IL_0006:  ret
     } 
 
-    .method public static class assembly/Weirdo 
-            get_C() cil managed
+    .method public static class assembly/Weirdo get_C() cil managed
     {
       .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
                                                                                                   int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
@@ -95,8 +92,7 @@
       IL_0005:  ret
     } 
 
-    .method public hidebysig instance int32 
-            get_Tag() cil managed
+    .method public hidebysig instance int32 get_Tag() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -108,8 +104,7 @@
       IL_0003:  ret
     } 
 
-    .method assembly hidebysig specialname 
-            instance object  __DebugDisplay() cil managed
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -123,8 +118,7 @@
       IL_0015:  ret
     } 
 
-    .method public strict virtual instance string 
-            ToString() cil managed
+    .method public strict virtual instance string ToString() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -137,8 +131,7 @@
       IL_0015:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(class assembly/Weirdo obj) cil managed
+    .method public hidebysig virtual final instance int32  CompareTo(class assembly/Weirdo obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -165,8 +158,7 @@
       IL_0010:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(object obj) cil managed
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -213,8 +205,7 @@
       IL_0021:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -234,8 +225,7 @@
       IL_000a:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode() cil managed
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -280,8 +270,7 @@
       IL_001a:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance bool  Equals(class assembly/Weirdo obj) cil managed
+    .method public hidebysig virtual final instance bool  Equals(class assembly/Weirdo obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -302,8 +291,7 @@
       IL_000f:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance bool  Equals(object obj) cil managed
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -345,8 +333,7 @@
          extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,int32>
   {
     .field public int32 C
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(int32 C) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(int32 C) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -360,8 +347,7 @@
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance int32 
-            Invoke(class assembly/Weirdo _arg1) cil managed
+    .method public strict virtual instance int32 Invoke(class assembly/Weirdo _arg1) cil managed
     {
       
       .maxstack  5
@@ -476,8 +462,7 @@
     IL_0014:  ret
   } 
 
-  .method public hidebysig specialname instance class [runtime]System.Type 
-          get_Type() cil managed
+  .method public hidebysig specialname instance class [runtime]System.Type get_Type() cil managed
   {
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -488,8 +473,7 @@
     IL_0006:  ret
   } 
 
-  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes 
-          get_MemberType() cil managed
+  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes get_MemberType() cil managed
   {
     .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/GeneralizationOnUnions01.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/GeneralizationOnUnions01.fs.RealInternalSignatureOff.il.netcore.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/GeneralizationOnUnions01.fs.il.netcore.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/GeneralizationOnUnions01.fs.RealInternalSignatureOff.il.netcore.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/GeneralizationOnUnions01.fs.RealInternalSignatureOn.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/GeneralizationOnUnions01.fs.RealInternalSignatureOn.il.net472.bsl
new file mode 100644
index 00000000000..dd0d3a7a9b2
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/GeneralizationOnUnions01.fs.RealInternalSignatureOn.il.net472.bsl
@@ -0,0 +1,526 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Weirdo
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class assembly/Weirdo>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class assembly/Weirdo>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                   61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field static assembly initonly class assembly/Weirdo _unique_C
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  newobj     instance void assembly/Weirdo::.ctor()
+      IL_0005:  stsfld     class assembly/Weirdo assembly/Weirdo::_unique_C
+      IL_000a:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                              class [runtime]System.Type) = ( 01 00 E0 07 00 00 1F 47 65 6E 65 72 61 6C 69 7A   
+                                                                                                                               61 74 69 6F 6E 4F 6E 55 6E 69 6F 6E 73 30 31 2B   
+                                                                                                                               57 65 69 72 64 6F 00 00 )                         
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public static class assembly/Weirdo get_C() cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldsfld     class assembly/Weirdo assembly/Weirdo::_unique_C
+      IL_0005:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class assembly/Weirdo>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class assembly/Weirdo obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_000a
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_0008
+
+      IL_0006:  ldc.i4.0
+      IL_0007:  ret
+
+      IL_0008:  ldc.i4.1
+      IL_0009:  ret
+
+      IL_000a:  ldarg.1
+      IL_000b:  brfalse.s  IL_000f
+
+      IL_000d:  ldc.i4.m1
+      IL_000e:  ret
+
+      IL_000f:  ldc.i4.0
+      IL_0010:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  assembly/Weirdo
+      IL_0007:  callvirt   instance int32 assembly/Weirdo::CompareTo(class assembly/Weirdo)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (class assembly/Weirdo V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  assembly/Weirdo
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_0016
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  assembly/Weirdo
+      IL_0010:  brfalse.s  IL_0014
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+
+      IL_0014:  ldc.i4.1
+      IL_0015:  ret
+
+      IL_0016:  ldarg.1
+      IL_0017:  unbox.any  assembly/Weirdo
+      IL_001c:  brfalse.s  IL_0020
+
+      IL_001e:  ldc.i4.m1
+      IL_001f:  ret
+
+      IL_0020:  ldc.i4.0
+      IL_0021:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0009
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldc.i4.0
+      IL_0008:  ret
+
+      IL_0009:  ldc.i4.0
+      IL_000a:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 assembly/Weirdo::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class assembly/Weirdo V_0,
+               class assembly/Weirdo V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0013
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     assembly/Weirdo
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0011
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldc.i4.1
+      IL_0010:  ret
+
+      IL_0011:  ldc.i4.0
+      IL_0012:  ret
+
+      IL_0013:  ldarg.1
+      IL_0014:  ldnull
+      IL_0015:  cgt.un
+      IL_0017:  ldc.i4.0
+      IL_0018:  ceq
+      IL_001a:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class assembly/Weirdo obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0008
+
+      IL_0003:  ldarg.1
+      IL_0004:  ldnull
+      IL_0005:  cgt.un
+      IL_0007:  ret
+
+      IL_0008:  ldarg.1
+      IL_0009:  ldnull
+      IL_000a:  cgt.un
+      IL_000c:  ldc.i4.0
+      IL_000d:  ceq
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class assembly/Weirdo V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     assembly/Weirdo
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool assembly/Weirdo::Equals(class assembly/Weirdo)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 assembly/Weirdo::get_Tag()
+    } 
+    .property class assembly/Weirdo
+            C()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get class assembly/Weirdo assembly/Weirdo::get_C()
+    } 
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit f@8
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,int32>
+  {
+    .field public int32 C
+    .method assembly specialname rtspecialname instance void  .ctor(int32 C) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,int32>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 assembly/f@8::C
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class assembly/Weirdo _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class assembly/Weirdo V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      int32 assembly/f@8::C
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .method public static int32  f(class assembly/Weirdo C) cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class assembly/Weirdo V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  ret
+  } 
+
+  .method public static void  g() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (int32 V_0,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,int32> V_1)
+    IL_0000:  ldc.i4.1
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  newobj     instance void assembly/f@8::.ctor(int32)
+    IL_0008:  stloc.1
+    IL_0009:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_0006:  pop
+    IL_0007:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private auto ansi serializable sealed System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+       extends [runtime]System.Enum
+{
+  .custom instance void [runtime]System.FlagsAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field public specialname rtspecialname int32 value__
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes All = int32(0xFFFFFFFF)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes None = int32(0x00000000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicParameterlessConstructor = int32(0x00000001)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicConstructors = int32(0x00000003)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicConstructors = int32(0x00000004)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicMethods = int32(0x00000008)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicMethods = int32(0x00000010)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicFields = int32(0x00000020)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicFields = int32(0x00000040)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicNestedTypes = int32(0x00000080)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicNestedTypes = int32(0x00000100)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicProperties = int32(0x00000200)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicProperties = int32(0x00000400)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicEvents = int32(0x00000800)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicEvents = int32(0x00001000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes Interfaces = int32(0x00002000)
+} 
+
+.class private auto ansi beforefieldinit System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute
+       extends [runtime]System.Attribute
+{
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private class [runtime]System.Type Type@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public specialname rtspecialname 
+          instance void  .ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType,
+                               class [runtime]System.Type Type) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Attribute::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_000d:  ldarg.0
+    IL_000e:  ldarg.2
+    IL_000f:  stfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0014:  ret
+  } 
+
+  .method public hidebysig specialname instance class [runtime]System.Type get_Type() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes get_MemberType() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_0006:  ret
+  } 
+
+  .property instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+          MemberType()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_MemberType()
+  } 
+  .property instance class [runtime]System.Type
+          Type()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_Type()
+  } 
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/GeneralizationOnUnions01.fs.RealInternalSignatureOn.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/GeneralizationOnUnions01.fs.RealInternalSignatureOn.il.netcore.bsl
new file mode 100644
index 00000000000..2f63fb5a58f
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/GeneralizationOnUnions01.fs.RealInternalSignatureOn.il.netcore.bsl
@@ -0,0 +1,434 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Weirdo
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class assembly/Weirdo>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class assembly/Weirdo>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                         61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field static assembly initonly class assembly/Weirdo _unique_C
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  newobj     instance void assembly/Weirdo::.ctor()
+      IL_0005:  stsfld     class assembly/Weirdo assembly/Weirdo::_unique_C
+      IL_000a:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                              class [runtime]System.Type) = ( 01 00 E0 07 00 00 1F 47 65 6E 65 72 61 6C 69 7A   
+                                                                                                                                                     61 74 69 6F 6E 4F 6E 55 6E 69 6F 6E 73 30 31 2B   
+                                                                                                                                                     57 65 69 72 64 6F 00 00 )                         
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public static class assembly/Weirdo get_C() cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldsfld     class assembly/Weirdo assembly/Weirdo::_unique_C
+      IL_0005:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class assembly/Weirdo>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class assembly/Weirdo obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_000a
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_0008
+
+      IL_0006:  ldc.i4.0
+      IL_0007:  ret
+
+      IL_0008:  ldc.i4.1
+      IL_0009:  ret
+
+      IL_000a:  ldarg.1
+      IL_000b:  brfalse.s  IL_000f
+
+      IL_000d:  ldc.i4.m1
+      IL_000e:  ret
+
+      IL_000f:  ldc.i4.0
+      IL_0010:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  assembly/Weirdo
+      IL_0007:  callvirt   instance int32 assembly/Weirdo::CompareTo(class assembly/Weirdo)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (class assembly/Weirdo V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  assembly/Weirdo
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_0016
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  assembly/Weirdo
+      IL_0010:  brfalse.s  IL_0014
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+
+      IL_0014:  ldc.i4.1
+      IL_0015:  ret
+
+      IL_0016:  ldarg.1
+      IL_0017:  unbox.any  assembly/Weirdo
+      IL_001c:  brfalse.s  IL_0020
+
+      IL_001e:  ldc.i4.m1
+      IL_001f:  ret
+
+      IL_0020:  ldc.i4.0
+      IL_0021:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  3
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0009
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldc.i4.0
+      IL_0008:  ret
+
+      IL_0009:  ldc.i4.0
+      IL_000a:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 assembly/Weirdo::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class assembly/Weirdo V_0,
+               class assembly/Weirdo V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0013
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     assembly/Weirdo
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0011
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldc.i4.1
+      IL_0010:  ret
+
+      IL_0011:  ldc.i4.0
+      IL_0012:  ret
+
+      IL_0013:  ldarg.1
+      IL_0014:  ldnull
+      IL_0015:  cgt.un
+      IL_0017:  ldc.i4.0
+      IL_0018:  ceq
+      IL_001a:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class assembly/Weirdo obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0008
+
+      IL_0003:  ldarg.1
+      IL_0004:  ldnull
+      IL_0005:  cgt.un
+      IL_0007:  ret
+
+      IL_0008:  ldarg.1
+      IL_0009:  ldnull
+      IL_000a:  cgt.un
+      IL_000c:  ldc.i4.0
+      IL_000d:  ceq
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class assembly/Weirdo V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     assembly/Weirdo
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool assembly/Weirdo::Equals(class assembly/Weirdo)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 assembly/Weirdo::get_Tag()
+    } 
+    .property class assembly/Weirdo
+            C()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get class assembly/Weirdo assembly/Weirdo::get_C()
+    } 
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit f@8
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,int32>
+  {
+    .field public int32 C
+    .method assembly specialname rtspecialname instance void  .ctor(int32 C) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,int32>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 assembly/f@8::C
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class assembly/Weirdo _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class assembly/Weirdo V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      int32 assembly/f@8::C
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .method public static int32  f(class assembly/Weirdo C) cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class assembly/Weirdo V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  ret
+  } 
+
+  .method public static void  g() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (int32 V_0,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class assembly/Weirdo,int32> V_1)
+    IL_0000:  ldc.i4.1
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  newobj     instance void assembly/f@8::.ctor(int32)
+    IL_0008:  stloc.1
+    IL_0009:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_0006:  pop
+    IL_0007:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/IfThenElse01.fs.RealInternalSignatureOff.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/IfThenElse01.fs.RealInternalSignatureOff.il.bsl
new file mode 100644
index 00000000000..b2c1885cc93
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/IfThenElse01.fs.RealInternalSignatureOff.il.bsl
@@ -0,0 +1,201 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public M
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto ansi serializable sealed nested assembly beforefieldinit f5@5
+           extends [FSharp.Core]Microsoft.FSharp.Core.FSharpTypeFunc
+    {
+      .field static assembly initonly class assembly/M/f5@5 @_instance
+      .method assembly specialname rtspecialname instance void  .ctor() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpTypeFunc::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance object Specialize<a>() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void class assembly/M/f5@5T<!!a>::.ctor(class assembly/M/f5@5)
+        IL_0006:  box        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!a,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!a,!!a>>>>
+        IL_000b:  ret
+      } 
+
+      .method private specialname rtspecialname static void  .cctor() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  10
+        IL_0000:  newobj     instance void assembly/M/f5@5::.ctor()
+        IL_0005:  stsfld     class assembly/M/f5@5 assembly/M/f5@5::@_instance
+        IL_000a:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit f5@5T<a>
+           extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`5<int32,int32,!a,!a,!a>
+    {
+      .field public class assembly/M/f5@5 self0@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class assembly/M/f5@5 self0@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`5<int32,int32,!a,!a,!a>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class assembly/M/f5@5 class assembly/M/f5@5T<!a>::self0@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance !a 
+              Invoke(int32 x,
+                     int32 y,
+                     !a z,
+                     !a w) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (class assembly/M/f5@5 V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class assembly/M/f5@5 class assembly/M/f5@5T<!a>::self0@
+        IL_0006:  stloc.0
+        IL_0007:  nop
+        IL_0008:  ldarg.1
+        IL_0009:  ldarg.2
+        IL_000a:  ble.s      IL_000e
+
+        IL_000c:  ldarg.3
+        IL_000d:  ret
+
+        IL_000e:  ldarg.s    w
+        IL_0010:  ret
+      } 
+
+    } 
+
+    .method public static char  m() cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpTypeFunc V_0,
+               char V_1,
+               char V_2,
+               int32 V_3,
+               int32 V_4)
+      IL_0000:  ldsfld     class assembly/M/f5@5 assembly/M/f5@5::@_instance
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  ldc.i4.s   10
+      IL_0009:  ldc.i4.s   10
+      IL_000b:  ldc.i4.s   97
+      IL_000d:  ldc.i4.s   98
+      IL_000f:  stloc.1
+      IL_0010:  stloc.2
+      IL_0011:  stloc.3
+      IL_0012:  stloc.s    V_4
+      IL_0014:  callvirt   instance object [FSharp.Core]Microsoft.FSharp.Core.FSharpTypeFunc::Specialize<char>()
+      IL_0019:  unbox.any  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>>>>
+      IL_001e:  ldloc.s    V_4
+      IL_0020:  ldloc.3
+      IL_0021:  ldloc.2
+      IL_0022:  ldloc.1
+      IL_0023:  tail.
+      IL_0025:  call       !!2 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::InvokeFast<char,char,char>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!1,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!1,!!2>>>>,
+                                                                                                                              !0,
+                                                                                                                              !1,
+                                                                                                                              !!0,
+                                                                                                                              !!1)
+      IL_002a:  ret
+    } 
+
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       char assembly/M::m()
+    IL_0005:  pop
+    IL_0006:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/IfThenElse01.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/IfThenElse01.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..b2c1885cc93
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/IfThenElse01.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,201 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public M
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto ansi serializable sealed nested assembly beforefieldinit f5@5
+           extends [FSharp.Core]Microsoft.FSharp.Core.FSharpTypeFunc
+    {
+      .field static assembly initonly class assembly/M/f5@5 @_instance
+      .method assembly specialname rtspecialname instance void  .ctor() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpTypeFunc::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance object Specialize<a>() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void class assembly/M/f5@5T<!!a>::.ctor(class assembly/M/f5@5)
+        IL_0006:  box        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!a,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!a,!!a>>>>
+        IL_000b:  ret
+      } 
+
+      .method private specialname rtspecialname static void  .cctor() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  10
+        IL_0000:  newobj     instance void assembly/M/f5@5::.ctor()
+        IL_0005:  stsfld     class assembly/M/f5@5 assembly/M/f5@5::@_instance
+        IL_000a:  ret
+      } 
+
+    } 
+
+    .class auto ansi serializable sealed nested assembly beforefieldinit f5@5T<a>
+           extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`5<int32,int32,!a,!a,!a>
+    {
+      .field public class assembly/M/f5@5 self0@
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method assembly specialname rtspecialname instance void  .ctor(class assembly/M/f5@5 self0@) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`5<int32,int32,!a,!a,!a>::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      class assembly/M/f5@5 class assembly/M/f5@5T<!a>::self0@
+        IL_000d:  ret
+      } 
+
+      .method public strict virtual instance !a 
+              Invoke(int32 x,
+                     int32 y,
+                     !a z,
+                     !a w) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (class assembly/M/f5@5 V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class assembly/M/f5@5 class assembly/M/f5@5T<!a>::self0@
+        IL_0006:  stloc.0
+        IL_0007:  nop
+        IL_0008:  ldarg.1
+        IL_0009:  ldarg.2
+        IL_000a:  ble.s      IL_000e
+
+        IL_000c:  ldarg.3
+        IL_000d:  ret
+
+        IL_000e:  ldarg.s    w
+        IL_0010:  ret
+      } 
+
+    } 
+
+    .method public static char  m() cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpTypeFunc V_0,
+               char V_1,
+               char V_2,
+               int32 V_3,
+               int32 V_4)
+      IL_0000:  ldsfld     class assembly/M/f5@5 assembly/M/f5@5::@_instance
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  ldc.i4.s   10
+      IL_0009:  ldc.i4.s   10
+      IL_000b:  ldc.i4.s   97
+      IL_000d:  ldc.i4.s   98
+      IL_000f:  stloc.1
+      IL_0010:  stloc.2
+      IL_0011:  stloc.3
+      IL_0012:  stloc.s    V_4
+      IL_0014:  callvirt   instance object [FSharp.Core]Microsoft.FSharp.Core.FSharpTypeFunc::Specialize<char>()
+      IL_0019:  unbox.any  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<char,char>>>>
+      IL_001e:  ldloc.s    V_4
+      IL_0020:  ldloc.3
+      IL_0021:  ldloc.2
+      IL_0022:  ldloc.1
+      IL_0023:  tail.
+      IL_0025:  call       !!2 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::InvokeFast<char,char,char>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!1,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!1,!!2>>>>,
+                                                                                                                              !0,
+                                                                                                                              !1,
+                                                                                                                              !!0,
+                                                                                                                              !!1)
+      IL_002a:  ret
+    } 
+
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       char assembly/M::m()
+    IL_0005:  pop
+    IL_0006:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/IfThenElse01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/IfThenElse01.fs.il.bsl
index 01992dbfb9d..bb7789ea103 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/IfThenElse01.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/IfThenElse01.fs.il.bsl
@@ -51,8 +51,7 @@
            extends [FSharp.Core]Microsoft.FSharp.Core.FSharpTypeFunc
     {
       .field static assembly initonly class assembly/M/f5@5 @_instance
-      .method assembly specialname rtspecialname 
-              instance void  .ctor() cil managed
+      .method assembly specialname rtspecialname instance void  .ctor() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -65,8 +64,7 @@
         IL_0006:  ret
       } 
 
-      .method public strict virtual instance object 
-              Specialize<a>() cil managed
+      .method public strict virtual instance object Specialize<a>() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -78,8 +76,7 @@
         IL_000b:  ret
       } 
 
-      .method private specialname rtspecialname static 
-              void  .cctor() cil managed
+      .method private specialname rtspecialname static void  .cctor() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -99,8 +96,7 @@
       .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-      .method assembly specialname rtspecialname 
-              instance void  .ctor(class assembly/M/f5@5 self0@) cil managed
+      .method assembly specialname rtspecialname instance void  .ctor(class assembly/M/f5@5 self0@) cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -175,6 +171,45 @@
       IL_002a:  ret
     } 
 
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  call       char assembly/M::m()
+      IL_0005:  pop
+      IL_0006:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/M::staticInitialization@()
+    IL_0005:  ret
   } 
 
 } 
@@ -191,9 +226,8 @@
     .entrypoint
     
     .maxstack  8
-    IL_0000:  call       char assembly/M::m()
-    IL_0005:  pop
-    IL_0006:  ret
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
   } 
 
 } 
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/LetIfThenElse01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/LetIfThenElse01.fs.RealInternalSignatureOff.il.bsl
similarity index 96%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/LetIfThenElse01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/LetIfThenElse01.fs.RealInternalSignatureOff.il.bsl
index 77d2bb8bcf4..51d7e424843 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/LetIfThenElse01.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/LetIfThenElse01.fs.RealInternalSignatureOff.il.bsl
@@ -43,8 +43,7 @@
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
-  .method public static class [runtime]System.Tuple`4<int32,int32,int32,int32> 
-          F<a>(!!a y) cil managed
+  .method public static class [runtime]System.Tuple`4<int32,int32,int32,int32> F<a>(!!a y) cil managed
   {
     
     .maxstack  6
@@ -121,9 +120,9 @@
     IL_0076:  ldloc.s    V_4
     IL_0078:  ldloc.s    V_6
     IL_007a:  newobj     instance void class [runtime]System.Tuple`4<int32,int32,int32,int32>::.ctor(!0,
-                                                                                                            !1,
-                                                                                                            !2,
-                                                                                                            !3)
+                                                                                                      !1,
+                                                                                                      !2,
+                                                                                                      !3)
     IL_007f:  ret
   } 
 
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/LetIfThenElse01.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/LetIfThenElse01.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..72bd28ab1d7
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/LetIfThenElse01.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,178 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static class [runtime]System.Tuple`4<int32,int32,int32,int32> F<a>(!!a y) cil managed
+  {
+    
+    .maxstack  6
+    .locals init (int32 V_0,
+             valuetype [runtime]System.DateTime V_1,
+             int32 V_2,
+             valuetype [runtime]System.DateTime V_3,
+             int32 V_4,
+             valuetype [runtime]System.DateTime V_5,
+             int32 V_6,
+             valuetype [runtime]System.DateTime V_7)
+    IL_0000:  nop
+    IL_0001:  call       valuetype [runtime]System.DateTime [runtime]System.DateTime::get_Now()
+    IL_0006:  stloc.1
+    IL_0007:  ldloca.s   V_1
+    IL_0009:  call       instance int32 [runtime]System.DateTime::get_Year()
+    IL_000e:  ldc.i4     0x7d0
+    IL_0013:  ble.s      IL_0019
+
+    IL_0015:  ldc.i4.1
+    IL_0016:  nop
+    IL_0017:  br.s       IL_001b
+
+    IL_0019:  ldc.i4.2
+    IL_001a:  nop
+    IL_001b:  stloc.0
+    IL_001c:  nop
+    IL_001d:  call       valuetype [runtime]System.DateTime [runtime]System.DateTime::get_Now()
+    IL_0022:  stloc.3
+    IL_0023:  ldloca.s   V_3
+    IL_0025:  call       instance int32 [runtime]System.DateTime::get_Year()
+    IL_002a:  ldc.i4     0x7d0
+    IL_002f:  ble.s      IL_0035
+
+    IL_0031:  ldc.i4.1
+    IL_0032:  nop
+    IL_0033:  br.s       IL_0037
+
+    IL_0035:  ldc.i4.2
+    IL_0036:  nop
+    IL_0037:  stloc.2
+    IL_0038:  nop
+    IL_0039:  call       valuetype [runtime]System.DateTime [runtime]System.DateTime::get_Now()
+    IL_003e:  stloc.s    V_5
+    IL_0040:  ldloca.s   V_5
+    IL_0042:  call       instance int32 [runtime]System.DateTime::get_Year()
+    IL_0047:  ldc.i4     0x7d0
+    IL_004c:  bge.s      IL_0052
+
+    IL_004e:  ldc.i4.1
+    IL_004f:  nop
+    IL_0050:  br.s       IL_0054
+
+    IL_0052:  ldc.i4.2
+    IL_0053:  nop
+    IL_0054:  stloc.s    V_4
+    IL_0056:  nop
+    IL_0057:  call       valuetype [runtime]System.DateTime [runtime]System.DateTime::get_Now()
+    IL_005c:  stloc.s    V_7
+    IL_005e:  ldloca.s   V_7
+    IL_0060:  call       instance int32 [runtime]System.DateTime::get_Year()
+    IL_0065:  ldc.i4     0x7d0
+    IL_006a:  bge.s      IL_0070
+
+    IL_006c:  ldc.i4.1
+    IL_006d:  nop
+    IL_006e:  br.s       IL_0072
+
+    IL_0070:  ldc.i4.2
+    IL_0071:  nop
+    IL_0072:  stloc.s    V_6
+    IL_0074:  ldloc.0
+    IL_0075:  ldloc.2
+    IL_0076:  ldloc.s    V_4
+    IL_0078:  ldloc.s    V_6
+    IL_007a:  newobj     instance void class [runtime]System.Tuple`4<int32,int32,int32,int32>::.ctor(!0,
+                                                                                                      !1,
+                                                                                                      !2,
+                                                                                                      !3)
+    IL_007f:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class [runtime]System.Tuple`4<int32,int32,int32,int32> V_0,
+             class [runtime]System.Tuple`4<int32,int32,int32,int32> V_1)
+    IL_0000:  ldc.i4.1
+    IL_0001:  call       class [runtime]System.Tuple`4<int32,int32,int32,int32> assembly::F<int32>(!!0)
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  stloc.1
+    IL_0009:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Lock01.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Lock01.fs.RealInternalSignatureOff.il.net472.bsl
similarity index 97%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Lock01.fs.il.net472.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Lock01.fs.RealInternalSignatureOff.il.net472.bsl
index 73c15706a8b..69538d40cd0 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Lock01.fs.il.net472.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Lock01.fs.RealInternalSignatureOff.il.net472.bsl
@@ -48,8 +48,7 @@
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
-  .method public specialname static object 
-          get_o() cil managed
+  .method public specialname static object get_o() cil managed
   {
     
     .maxstack  8
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Lock01.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Lock01.fs.RealInternalSignatureOff.il.netcore.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Lock01.fs.il.netcore.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Lock01.fs.RealInternalSignatureOff.il.netcore.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Lock01.fs.RealInternalSignatureOn.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Lock01.fs.RealInternalSignatureOn.il.net472.bsl
new file mode 100644
index 00000000000..e67218a9cd4
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Lock01.fs.RealInternalSignatureOn.il.net472.bsl
@@ -0,0 +1,135 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly object o@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static object get_o() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     object assembly::o@19
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (object V_0,
+             bool V_1)
+    IL_0000:  newobj     instance void [runtime]System.Object::.ctor()
+    IL_0005:  stsfld     object assembly::o@19
+    IL_000a:  call       object assembly::get_o()
+    IL_000f:  stloc.0
+    IL_0010:  ldc.i4.0
+    IL_0011:  stloc.1
+    .try
+    {
+      IL_0012:  ldloc.0
+      IL_0013:  ldloca.s   V_1
+      IL_0015:  call       void [netstandard]System.Threading.Monitor::Enter(object,
+                                                                             bool&)
+      IL_001a:  leave.s    IL_0027
+
+    }  
+    finally
+    {
+      IL_001c:  ldloc.1
+      IL_001d:  brfalse.s  IL_0026
+
+      IL_001f:  ldloc.0
+      IL_0020:  call       void [netstandard]System.Threading.Monitor::Exit(object)
+      IL_0025:  endfinally
+      IL_0026:  endfinally
+    }  
+    IL_0027:  ret
+  } 
+
+  .property object o()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get object assembly::get_o()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Lock01.fs.RealInternalSignatureOn.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Lock01.fs.RealInternalSignatureOn.il.netcore.bsl
new file mode 100644
index 00000000000..8e0327d73c7
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Lock01.fs.RealInternalSignatureOn.il.netcore.bsl
@@ -0,0 +1,135 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly object o@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static object get_o() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     object assembly::o@19
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (object V_0,
+             bool V_1)
+    IL_0000:  newobj     instance void [runtime]System.Object::.ctor()
+    IL_0005:  stsfld     object assembly::o@19
+    IL_000a:  call       object assembly::get_o()
+    IL_000f:  stloc.0
+    IL_0010:  ldc.i4.0
+    IL_0011:  stloc.1
+    .try
+    {
+      IL_0012:  ldloc.0
+      IL_0013:  ldloca.s   V_1
+      IL_0015:  call       void [netstandard]System.Threading.Monitor::Enter(object,
+                                                                             bool&)
+      IL_001a:  leave.s    IL_0027
+
+    }  
+    finally
+    {
+      IL_001c:  ldloc.1
+      IL_001d:  brfalse.s  IL_0026
+
+      IL_001f:  ldloc.0
+      IL_0020:  call       void [netstandard]System.Threading.Monitor::Exit(object)
+      IL_0025:  endfinally
+      IL_0026:  endfinally
+    }  
+    IL_0027:  ret
+  } 
+
+  .property object o()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get object assembly::get_o()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/MethodImplNoInline02.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/MethodImplNoInline02.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/MethodImplNoInline02.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/MethodImplNoInline02.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/MethodImplNoInline02.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/MethodImplNoInline02.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..8d512541da2
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/MethodImplNoInline02.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,110 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  g() cil managed noinlining
+  {
+    
+    .maxstack  8
+    IL_0000:  ldstr      "Hey!"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_000f:  pop
+    IL_0010:  ret
+  } 
+
+  .method public static void  f() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  tail.
+    IL_0002:  call       void assembly::g()
+    IL_0007:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::g()
+    IL_0005:  nop
+    IL_0006:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Misc.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Misc.fs
index 49bd8a47ff5..5e8206137b1 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Misc.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Misc.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open Xunit
 open System.IO
@@ -16,6 +16,23 @@ module Misc =
         |> ignoreWarnings
         |> verifyILBaseline
 
+
+    // SOURCE=AbstractClass.fs             SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd AbstractClass.exe"	# AbstractClass.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"AbstractClass.fs"|])>]
+    let ``AbstractClass_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> asExe
+        |> verifyCompilation
+
+    // SOURCE=AbstractClass.fs             SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd AbstractClass.exe"	# AbstractClass.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"AbstractClass.fs"|])>]
+    let ``AbstractClass_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> asExe
+        |> verifyCompilation
+
     // SOURCE=AnonRecd.fs                  SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd AnonRecd.exe"	# AnonRecd.fs
     [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"AnonRecd.fs"|])>]
     let ``AnonRecd_fs`` compilation =
@@ -24,30 +41,66 @@ module Misc =
         |> verifyCompilation
 
     // SOURCE=CodeGenRenamings01.fs        SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd CodeGenRenamings01.exe"	# CodeGenRenamings01.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"CodeGenRenamings01.fs"|])>]
-    let ``CodeGenRenamings01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__,  BaselineSuffix=".RealInternalSignatureOn",Includes=[|"CodeGenRenamings01.fs"|])>]
+    let ``CodeGenRenamings01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> asExe
+        |> verifyCompilation
+
+    // SOURCE=CodeGenRenamings01.fs        SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd CodeGenRenamings01.exe"	# CodeGenRenamings01.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"CodeGenRenamings01.fs"|])>]
+    let ``CodeGenRenamings01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
         |> asExe
         |> verifyCompilation
 
     // SOURCE=ArgumentNamesInClosures01.fs SCFLAGS="-a -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ArgumentNamesInClosures01.dll"	# ArgumentNamesInClosures01.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ArgumentNamesInClosures01.fs"|])>]
-    let ``ArgumentNamesInClosures01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ArgumentNamesInClosures01.fs"|])>]
+    let ``ArgumentNamesInClosures01_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> asExe
+        |> verifyCompilation
+
+    // SOURCE=ArgumentNamesInClosures01.fs SCFLAGS="-a -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ArgumentNamesInClosures01.dll"	# ArgumentNamesInClosures01.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ArgumentNamesInClosures01.fs"|])>]
+    let ``ArgumentNamesInClosures01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> asExe
+        |> verifyCompilation
+
+    // SOURCE=Decimal01.fs                 SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Decimal01.exe"			# Decimal01.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Decimal01.fs"|])>]
+    let ``Decimal01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> asExe
         |> verifyCompilation
 
     // SOURCE=Decimal01.fs                 SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Decimal01.exe"			# Decimal01.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Decimal01.fs"|])>]
-    let ``Decimal01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Decimal01.fs"|])>]
+    let ``Decimal01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> asExe
+        |> verifyCompilation
+
+    // SOURCE=EntryPoint01.fs              SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd EntryPoint01.exe"		# EntryPoint01.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"EntryPoint01.fs"|])>]
+    let ``EntryPoint01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> asExe
         |> verifyCompilation
 
     // SOURCE=EntryPoint01.fs              SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd EntryPoint01.exe"		# EntryPoint01.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"EntryPoint01.fs"|])>]
-    let ``EntryPoint01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"EntryPoint01.fs"|])>]
+    let ``EntryPoint01_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> asExe
         |> verifyCompilation
 
@@ -59,23 +112,50 @@ module Misc =
         |> verifyCompilation
 
     // SOURCE=ForLoop01.fs                 SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ForLoop01.exe"	# ForLoop01.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ForLoop01.fs"|])>]
-    let ``ForLoop01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ForLoop01.fs"|])>]
+    let ``ForLoop01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> asExe
+        |> verifyCompilation
+
+    // SOURCE=ForLoop01.fs                 SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ForLoop01.exe"	# ForLoop01.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ForLoop01.fs"|])>]
+    let ``ForLoop01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> asExe
+        |> verifyCompilation
+
+    // SOURCE=ForLoop02.fs                 SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ForLoop02.exe"	# ForLoop02.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ForLoop02.fs"|])>]
+    let ``ForLoop02_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
         |> asExe
         |> verifyCompilation
 
     // SOURCE=ForLoop02.fs                 SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ForLoop02.exe"	# ForLoop02.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ForLoop02.fs"|])>]
-    let ``ForLoop02_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ForLoop02.fs"|])>]
+    let ``ForLoop02_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> asExe
+        |> verifyCompilation
+
+    // SOURCE=ForLoop03.fs                 SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ForLoop03.exe"	# ForLoop03.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ForLoop03.fs"|])>]
+    let ``ForLoop03_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> asExe
         |> verifyCompilation
 
     // SOURCE=ForLoop03.fs                 SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ForLoop03.exe"	# ForLoop03.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ForLoop02.fs"|])>]
-    let ``ForLoop03_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ForLoop03.fs"|])>]
+    let ``ForLoop03_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> asExe
         |> verifyCompilation
 
@@ -88,29 +168,65 @@ module Misc =
 
     //SOURCE=IfThenElse01.fs              SCFLAGS="-a -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd IfThenElse01.dll"		# IfThenElse01.fs
     [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"IfThenElse01.fs"|])>]
-    let ``IfThenElse01_fs`` compilation =
+    let ``IfThenElse01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> asExe
+        |> verifyCompilation
+
+    //SOURCE=IfThenElse01.fs              SCFLAGS="-a -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd IfThenElse01.dll"		# IfThenElse01.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"IfThenElse01.fs"|])>]
+    let ``IfThenElse01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> asExe
+        |> verifyCompilation
+
+    // SOURCE=LetIfThenElse01.fs           SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd LetIfThenElse01.exe"			# LetIfThenElse01.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"LetIfThenElse01.fs"|])>]
+    let ``LetIfThenElse01_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
         |> asExe
         |> verifyCompilation
 
     // SOURCE=LetIfThenElse01.fs           SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd LetIfThenElse01.exe"			# LetIfThenElse01.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"LetIfThenElse01.fs"|])>]
-    let ``LetIfThenElse01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"LetIfThenElse01.fs"|])>]
+    let ``LetIfThenElse01_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> asExe
         |> verifyCompilation
 
     // SOURCE=Lock01.fs                    SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Lock01.exe"	# Lock01.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Lock01.fs"|])>]
-    let ``Lock01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Lock01.fs"|])>]
+    let ``Lock01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> asExe
+        |> verifyCompilation
+
+    // SOURCE=Lock01.fs                    SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Lock01.exe"	# Lock01.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Lock01.fs"|])>]
+    let ``Lock01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
         |> asExe
         |> verifyCompilation
 
     // SOURCE=ModuleWithExpression01.fs    SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ModuleWithExpression01.exe"	# ModuleWithExpression01.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ModuleWithExpression01.fs"|])>]
-    let ``ModuleWithExpression01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ModuleWithExpression01.fs"|])>]
+    let ``ModuleWithExpression01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> asExe
+        |> verifyCompilation
+
+    // SOURCE=ModuleWithExpression01.fs    SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ModuleWithExpression01.exe"	# ModuleWithExpression01.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ModuleWithExpression01.fs"|])>]
+    let ``ModuleWithExpression01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
         |> asExe
         |> verifyCompilation
 
@@ -122,16 +238,34 @@ module Misc =
         |> verifyCompilation
 
     // SOURCE=Seq_for_all01.fs             SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Seq_for_all01.exe"		# Seq_for_all01.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Seq_for_all01.fs"|])>]
-    let ``Seq_for_all01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Seq_for_all01.fs"|])>]
+    let ``Seq_for_all01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> asExe
+        |> verifyCompilation
+
+    // SOURCE=Seq_for_all01.fs             SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Seq_for_all01.exe"		# Seq_for_all01.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Seq_for_all01.fs"|])>]
+    let ``Seq_for_all01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
         |> asExe
         |> verifyCompilation
 
     // SOURCE=StructsAsArrayElements01.fs  SCFLAGS="-a -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd StructsAsArrayElements01.dll"		# StructsAsArrayElements01.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"StructsAsArrayElements01.fs"|])>]
-    let ``StructsAsArrayElements01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"StructsAsArrayElements01.fs"|])>]
+    let ``StructsAsArrayElements01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> asExe
+        |> verifyCompilation
+
+    // SOURCE=StructsAsArrayElements01.fs  SCFLAGS="-a -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd StructsAsArrayElements01.dll"		# StructsAsArrayElements01.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"StructsAsArrayElements01.fs"|])>]
+    let ``StructsAsArrayElements01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
         |> asExe
         |> verifyCompilation
 
@@ -144,9 +278,19 @@ module Misc =
 
     // # The name of this test is a bit misleading for legacy reasons: it used to test the --no-generate-filter-blocks option, which is now gone
     // SOURCE=TryWith_NoFilterBlocks01.fs  SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TryWith_NoFilterBlocks01.exe"						# TryWith_NoFilterBlocks01.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TryWith_NoFilterBlocks01.fs"|])>]
-    let ``TryWith_NoFilterBlocks01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"TryWith_NoFilterBlocks01.fs"|])>]
+    let ``TryWith_NoFilterBlocks01_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> asExe
+        |> verifyCompilation
+
+    // # The name of this test is a bit misleading for legacy reasons: it used to test the --no-generate-filter-blocks option, which is now gone
+    // SOURCE=TryWith_NoFilterBlocks01.fs  SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TryWith_NoFilterBlocks01.exe"						# TryWith_NoFilterBlocks01.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"TryWith_NoFilterBlocks01.fs"|])>]
+    let ``TryWith_NoFilterBlocks01_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> asExe
         |> verifyCompilation
 
@@ -178,24 +322,35 @@ module Misc =
         |> asExe
         |> verifyCompilation
 
-    // SOURCE=MethodImplNoInline.fs        SCFLAGS="-O" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd MethodImplNoInline.exe"						# MethodImplNoInline.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ForLoop02.fs"|])>]
-    let ``MethodImplNoInline_fs`` compilation =
+    // SOURCE=MethodImplNoInline02.fs      SCFLAGS="-O" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd MethodImplNoInline02.exe"						# MethodImplNoInline02.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"MethodImplNoInline02.fs"|])>]
+    let ``MethodImplNoInline02_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> asExe
         |> verifyCompilation
 
     // SOURCE=MethodImplNoInline02.fs      SCFLAGS="-O" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd MethodImplNoInline02.exe"						# MethodImplNoInline02.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"MethodImplNoInline02.fs"|])>]
-    let ``MethodImplNoInline02_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"MethodImplNoInline02.fs"|])>]
+    let ``MethodImplNoInline02_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> asExe
         |> verifyCompilation
 
     // SOURCE=CustomAttributeGenericParameter01.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd CustomAttributeGenericParameter01.exe"	# CustomAttributeGenericParameter01.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"CustomAttributeGenericParameter01.fs"|])>]
-    let ``CustomAttributeGenericParameter01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"CustomAttributeGenericParameter01.fs"|])>]
+    let ``CustomAttributeGenericParameter01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> asExe
+        |> verifyCompilation
+
+    // SOURCE=CustomAttributeGenericParameter01.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd CustomAttributeGenericParameter01.exe"	# CustomAttributeGenericParameter01.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"CustomAttributeGenericParameter01.fs"|])>]
+    let ``CustomAttributeGenericParameter01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
         |> asExe
         |> verifyCompilation
 
@@ -206,16 +361,19 @@ module Misc =
         |> asExe
         |> verifyCompilation
 
+    // SOURCE=GenericTypeStaticField.fs  SCFLAGS="-g --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd GenericTypeStaticField.exe"	# GenericTypeStaticField.fs -
     // SOURCE=GeneralizationOnUnions01.fs  SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd GeneralizationOnUnions01.exe"	# GeneralizationOnUnions01.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"GeneralizationOnUnions01.fs"|])>]
-    let ``GeneralizationOnUnions01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"GeneralizationOnUnions01.fs"|])>]
+    let ``GeneralizationOnUnions01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> asExe
         |> verifyCompilation
 
-    // SOURCE=AbstractClass.fs             SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd AbstractClass.exe"	# AbstractClass.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"AbstractClass.fs"|])>]
-    let ``AbstractClass_fs`` compilation =
+    // SOURCE=GeneralizationOnUnions01.fs  SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd GeneralizationOnUnions01.exe"	# GeneralizationOnUnions01.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"GeneralizationOnUnions01.fs"|])>]
+    let ``GeneralizationOnUnions01_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> asExe
         |> verifyCompilation
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ModuleWithExpression01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ModuleWithExpression01.fs.RealInternalSignatureOff.il.bsl
similarity index 97%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ModuleWithExpression01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ModuleWithExpression01.fs.RealInternalSignatureOff.il.bsl
index 56dbb23e390..b66ece721b1 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ModuleWithExpression01.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ModuleWithExpression01.fs.RealInternalSignatureOff.il.bsl
@@ -47,8 +47,7 @@
          extends [runtime]System.Object
   {
     .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
-    .method public specialname static int32 
-            get_x() cil managed
+    .method public specialname static int32 get_x() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ModuleWithExpression01.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ModuleWithExpression01.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..c2f8529b0e1
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/ModuleWithExpression01.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,131 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public M
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .method public specialname static int32 get_x() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_000f:  pop
+      IL_0010:  ret
+    } 
+
+    .property int32 x()
+    {
+      .get int32 assembly/M::get_x()
+    } 
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/M::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Seq_for_all01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Seq_for_all01.fs.RealInternalSignatureOff.il.bsl
similarity index 93%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Seq_for_all01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Seq_for_all01.fs.RealInternalSignatureOff.il.bsl
index 4d71070d0bb..1a0a6d79b96 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Seq_for_all01.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Seq_for_all01.fs.RealInternalSignatureOff.il.bsl
@@ -47,8 +47,7 @@
          extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
   {
     .field static assembly initonly class assembly/q@4 @_instance
-    .method assembly specialname rtspecialname 
-            instance void  .ctor() cil managed
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -59,8 +58,7 @@
       IL_0006:  ret
     } 
 
-    .method public strict virtual instance bool 
-            Invoke(int32 s) cil managed
+    .method public strict virtual instance bool Invoke(int32 s) cil managed
     {
       
       .maxstack  8
@@ -80,8 +78,7 @@
       IL_000e:  ret
     } 
 
-    .method private specialname rtspecialname static 
-            void  .cctor() cil managed
+    .method private specialname rtspecialname static void  .cctor() cil managed
     {
       
       .maxstack  10
@@ -92,8 +89,7 @@
 
   } 
 
-  .method public specialname static bool 
-          get_q() cil managed
+  .method public specialname static bool get_q() cil managed
   {
     
     .maxstack  8
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Seq_for_all01.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Seq_for_all01.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..298df4dbc92
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Seq_for_all01.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,157 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit q@4
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/q@4 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 s) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  nop
+      IL_0001:  ldc.i4.1
+      IL_0002:  ldc.i4.0
+      IL_0003:  ceq
+      IL_0005:  nop
+      IL_0006:  brfalse.s  IL_000c
+
+      IL_0008:  nop
+      IL_0009:  nop
+      IL_000a:  br.s       IL_000d
+
+      IL_000c:  nop
+      IL_000d:  ldc.i4.1
+      IL_000e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/q@4::.ctor()
+      IL_0005:  stsfld     class assembly/q@4 assembly/q@4::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly bool q@4
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static bool get_q() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     bool assembly::q@4
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/q@4 assembly/q@4::@_instance
+    IL_0005:  ldc.i4.1
+    IL_0006:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0010:  call       bool [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ForAll<int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>,
+                                                                                                 class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0015:  stsfld     bool assembly::q@4
+    IL_001a:  ret
+  } 
+
+  .property bool q()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get bool assembly::get_q()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Structs01.fs.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Structs01.fs.il.release.bsl
index e50e9d4f74a..4216ba295eb 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Structs01.fs.il.release.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/Structs01.fs.il.release.bsl
@@ -1,302 +1,302 @@
-
-
-
-
-
-.assembly extern runtime { }
-.assembly extern FSharp.Core { }
-.assembly assembly
-{
-  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
-                                                                                                      int32,
-                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
-
-  
-  
-
-  .hash algorithm 0x00008004
-  .ver 0:0:0:0
-}
-.mresource public FSharpSignatureData.assembly
-{
-  
-  
-}
-.mresource public FSharpOptimizationData.assembly
-{
-  
-  
-}
-.module assembly.exe
-
-.imagebase {value}
-.file alignment 0x00000200
-.stackreserve 0x00100000
-.subsystem 0x0003       
-.corflags 0x00000001    
-
-
-
-
-
-.class public abstract auto ansi sealed Experiment.Test
-       extends [runtime]System.Object
-{
-  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
-  .class sequential ansi serializable sealed nested public Test
-         extends [runtime]System.ValueType
-         implements class [runtime]System.IEquatable`1<valuetype Experiment.Test/Test>,
-                    [runtime]System.Collections.IStructuralEquatable,
-                    class [runtime]System.IComparable`1<valuetype Experiment.Test/Test>,
-                    [runtime]System.IComparable,
-                    [runtime]System.Collections.IStructuralComparable
-  {
-    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
-    .field public int32 Field
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(valuetype Experiment.Test/Test obj) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  5
-      .locals init (valuetype Experiment.Test/Test& V_0,
-               class [runtime]System.Collections.IComparer V_1,
-               int32 V_2,
-               int32 V_3)
-      IL_0000:  ldarga.s   obj
-      IL_0002:  stloc.0
-      IL_0003:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
-      IL_0008:  stloc.1
-      IL_0009:  ldarg.0
-      IL_000a:  ldfld      int32 Experiment.Test/Test::Field
-      IL_000f:  stloc.2
-      IL_0010:  ldloc.0
-      IL_0011:  ldfld      int32 Experiment.Test/Test::Field
-      IL_0016:  stloc.3
-      IL_0017:  ldloc.2
-      IL_0018:  ldloc.3
-      IL_0019:  cgt
-      IL_001b:  ldloc.2
-      IL_001c:  ldloc.3
-      IL_001d:  clt
-      IL_001f:  sub
-      IL_0020:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(object obj) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  8
-      IL_0000:  ldarg.0
-      IL_0001:  ldarg.1
-      IL_0002:  unbox.any  Experiment.Test/Test
-      IL_0007:  call       instance int32 Experiment.Test/Test::CompareTo(valuetype Experiment.Test/Test)
-      IL_000c:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(object obj,
-                                      class [runtime]System.Collections.IComparer comp) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  5
-      .locals init (valuetype Experiment.Test/Test V_0,
-               valuetype Experiment.Test/Test& V_1,
-               class [runtime]System.Collections.IComparer V_2,
-               int32 V_3,
-               int32 V_4)
-      IL_0000:  ldarg.1
-      IL_0001:  unbox.any  Experiment.Test/Test
-      IL_0006:  stloc.0
-      IL_0007:  ldloca.s   V_0
-      IL_0009:  stloc.1
-      IL_000a:  ldarg.2
-      IL_000b:  stloc.2
-      IL_000c:  ldarg.0
-      IL_000d:  ldfld      int32 Experiment.Test/Test::Field
-      IL_0012:  stloc.3
-      IL_0013:  ldloc.1
-      IL_0014:  ldfld      int32 Experiment.Test/Test::Field
-      IL_0019:  stloc.s    V_4
-      IL_001b:  ldloc.3
-      IL_001c:  ldloc.s    V_4
-      IL_001e:  cgt
-      IL_0020:  ldloc.3
-      IL_0021:  ldloc.s    V_4
-      IL_0023:  clt
-      IL_0025:  sub
-      IL_0026:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  7
-      .locals init (int32 V_0,
-               class [runtime]System.Collections.IEqualityComparer V_1)
-      IL_0000:  ldc.i4.0
-      IL_0001:  stloc.0
-      IL_0002:  ldc.i4     0x9e3779b9
-      IL_0007:  ldarg.1
-      IL_0008:  stloc.1
-      IL_0009:  ldarg.0
-      IL_000a:  ldfld      int32 Experiment.Test/Test::Field
-      IL_000f:  ldloc.0
-      IL_0010:  ldc.i4.6
-      IL_0011:  shl
-      IL_0012:  ldloc.0
-      IL_0013:  ldc.i4.2
-      IL_0014:  shr
-      IL_0015:  add
-      IL_0016:  add
-      IL_0017:  add
-      IL_0018:  stloc.0
-      IL_0019:  ldloc.0
-      IL_001a:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode() cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  8
-      IL_0000:  ldarg.0
-      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
-      IL_0006:  call       instance int32 Experiment.Test/Test::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
-      IL_000b:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance bool  Equals(object obj,
-                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  4
-      .locals init (object V_0,
-               valuetype Experiment.Test/Test V_1,
-               valuetype Experiment.Test/Test& V_2,
-               class [runtime]System.Collections.IEqualityComparer V_3)
-      IL_0000:  ldarg.1
-      IL_0001:  stloc.0
-      IL_0002:  ldloc.0
-      IL_0003:  isinst     Experiment.Test/Test
-      IL_0008:  ldnull
-      IL_0009:  cgt.un
-      IL_000b:  brfalse.s  IL_0028
-
-      IL_000d:  ldarg.1
-      IL_000e:  unbox.any  Experiment.Test/Test
-      IL_0013:  stloc.1
-      IL_0014:  ldloca.s   V_1
-      IL_0016:  stloc.2
-      IL_0017:  ldarg.2
-      IL_0018:  stloc.3
-      IL_0019:  ldarg.0
-      IL_001a:  ldfld      int32 Experiment.Test/Test::Field
-      IL_001f:  ldloc.2
-      IL_0020:  ldfld      int32 Experiment.Test/Test::Field
-      IL_0025:  ceq
-      IL_0027:  ret
-
-      IL_0028:  ldc.i4.0
-      IL_0029:  ret
-    } 
-
-    .method public specialname rtspecialname 
-            instance void  .ctor(int32 i) cil managed
-    {
-      
-      .maxstack  8
-      IL_0000:  ldarg.0
-      IL_0001:  ldarg.1
-      IL_0002:  stfld      int32 Experiment.Test/Test::Field
-      IL_0007:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance bool  Equals(valuetype Experiment.Test/Test obj) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  4
-      .locals init (valuetype Experiment.Test/Test& V_0)
-      IL_0000:  ldarga.s   obj
-      IL_0002:  stloc.0
-      IL_0003:  ldarg.0
-      IL_0004:  ldfld      int32 Experiment.Test/Test::Field
-      IL_0009:  ldloc.0
-      IL_000a:  ldfld      int32 Experiment.Test/Test::Field
-      IL_000f:  ceq
-      IL_0011:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance bool  Equals(object obj) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  4
-      .locals init (object V_0,
-               valuetype Experiment.Test/Test V_1)
-      IL_0000:  ldarg.1
-      IL_0001:  stloc.0
-      IL_0002:  ldloc.0
-      IL_0003:  isinst     Experiment.Test/Test
-      IL_0008:  ldnull
-      IL_0009:  cgt.un
-      IL_000b:  brfalse.s  IL_001c
-
-      IL_000d:  ldarg.1
-      IL_000e:  unbox.any  Experiment.Test/Test
-      IL_0013:  stloc.1
-      IL_0014:  ldarg.0
-      IL_0015:  ldloc.1
-      IL_0016:  call       instance bool Experiment.Test/Test::Equals(valuetype Experiment.Test/Test)
-      IL_001b:  ret
-
-      IL_001c:  ldc.i4.0
-      IL_001d:  ret
-    } 
-
-  } 
-
-  .method public static int32  test() cil managed
-  {
-    
-    .maxstack  3
-    .locals init (valuetype Experiment.Test/Test V_0)
-    IL_0000:  ldc.i4.2
-    IL_0001:  newobj     instance void Experiment.Test/Test::.ctor(int32)
-    IL_0006:  stloc.0
-    IL_0007:  ldloca.s   V_0
-    IL_0009:  ldfld      int32 Experiment.Test/Test::Field
-    IL_000e:  ret
-  } 
-
-} 
-
-.class private abstract auto ansi sealed '<StartupCode$assembly>.$Experiment'.Test
-       extends [runtime]System.Object
-{
-  .method public static void  main@() cil managed
-  {
-    .entrypoint
-    
-    .maxstack  8
-    IL_0000:  ret
-  } 
-
-} 
-
-
-
-
-
-
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Experiment.Test
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class sequential ansi serializable sealed nested public Test
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype Experiment.Test/Test>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype Experiment.Test/Test>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field public int32 Field
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(valuetype Experiment.Test/Test obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (valuetype Experiment.Test/Test& V_0,
+               class [runtime]System.Collections.IComparer V_1,
+               int32 V_2,
+               int32 V_3)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0008:  stloc.1
+      IL_0009:  ldarg.0
+      IL_000a:  ldfld      int32 Experiment.Test/Test::Field
+      IL_000f:  stloc.2
+      IL_0010:  ldloc.0
+      IL_0011:  ldfld      int32 Experiment.Test/Test::Field
+      IL_0016:  stloc.3
+      IL_0017:  ldloc.2
+      IL_0018:  ldloc.3
+      IL_0019:  cgt
+      IL_001b:  ldloc.2
+      IL_001c:  ldloc.3
+      IL_001d:  clt
+      IL_001f:  sub
+      IL_0020:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  Experiment.Test/Test
+      IL_0007:  call       instance int32 Experiment.Test/Test::CompareTo(valuetype Experiment.Test/Test)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (valuetype Experiment.Test/Test V_0,
+               valuetype Experiment.Test/Test& V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  Experiment.Test/Test
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldarg.2
+      IL_000b:  stloc.2
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      int32 Experiment.Test/Test::Field
+      IL_0012:  stloc.3
+      IL_0013:  ldloc.1
+      IL_0014:  ldfld      int32 Experiment.Test/Test::Field
+      IL_0019:  stloc.s    V_4
+      IL_001b:  ldloc.3
+      IL_001c:  ldloc.s    V_4
+      IL_001e:  cgt
+      IL_0020:  ldloc.3
+      IL_0021:  ldloc.s    V_4
+      IL_0023:  clt
+      IL_0025:  sub
+      IL_0026:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1)
+      IL_0000:  ldc.i4.0
+      IL_0001:  stloc.0
+      IL_0002:  ldc.i4     0x9e3779b9
+      IL_0007:  ldarg.1
+      IL_0008:  stloc.1
+      IL_0009:  ldarg.0
+      IL_000a:  ldfld      int32 Experiment.Test/Test::Field
+      IL_000f:  ldloc.0
+      IL_0010:  ldc.i4.6
+      IL_0011:  shl
+      IL_0012:  ldloc.0
+      IL_0013:  ldc.i4.2
+      IL_0014:  shr
+      IL_0015:  add
+      IL_0016:  add
+      IL_0017:  add
+      IL_0018:  stloc.0
+      IL_0019:  ldloc.0
+      IL_001a:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 Experiment.Test/Test::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype Experiment.Test/Test V_1,
+               valuetype Experiment.Test/Test& V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     Experiment.Test/Test
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_0028
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  Experiment.Test/Test
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldarg.2
+      IL_0018:  stloc.3
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      int32 Experiment.Test/Test::Field
+      IL_001f:  ldloc.2
+      IL_0020:  ldfld      int32 Experiment.Test/Test::Field
+      IL_0025:  ceq
+      IL_0027:  ret
+
+      IL_0028:  ldc.i4.0
+      IL_0029:  ret
+    } 
+
+    .method public specialname rtspecialname 
+            instance void  .ctor(int32 i) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 Experiment.Test/Test::Field
+      IL_0007:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(valuetype Experiment.Test/Test obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype Experiment.Test/Test& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldarg.0
+      IL_0004:  ldfld      int32 Experiment.Test/Test::Field
+      IL_0009:  ldloc.0
+      IL_000a:  ldfld      int32 Experiment.Test/Test::Field
+      IL_000f:  ceq
+      IL_0011:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype Experiment.Test/Test V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     Experiment.Test/Test
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  Experiment.Test/Test
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool Experiment.Test/Test::Equals(valuetype Experiment.Test/Test)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+  } 
+
+  .method public static int32  test() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (valuetype Experiment.Test/Test V_0)
+    IL_0000:  ldc.i4.2
+    IL_0001:  newobj     instance void Experiment.Test/Test::.ctor(int32)
+    IL_0006:  stloc.0
+    IL_0007:  ldloca.s   V_0
+    IL_0009:  ldfld      int32 Experiment.Test/Test::Field
+    IL_000e:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>.$Experiment'.Test
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/StructsAsArrayElements01.fs.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/StructsAsArrayElements01.fs.RealInternalSignatureOff.il.debug.bsl
similarity index 92%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/StructsAsArrayElements01.fs.il.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/StructsAsArrayElements01.fs.RealInternalSignatureOff.il.debug.bsl
index fa9da73a37c..e7c07552242 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/StructsAsArrayElements01.fs.il.debug.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/StructsAsArrayElements01.fs.RealInternalSignatureOff.il.debug.bsl
@@ -54,8 +54,7 @@
     .custom instance void [FSharp.Core]Microsoft.FSharp.Core.StructAttribute::.ctor() = ( 01 00 00 00 ) 
     .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
     .field public int32 i
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(valuetype assembly/T obj) cil managed
+    .method public hidebysig virtual final instance int32  CompareTo(valuetype assembly/T obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -93,8 +92,7 @@
       IL_002d:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(object obj) cil managed
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -150,8 +148,7 @@
       IL_0032:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -185,8 +182,7 @@
       IL_001e:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode() cil managed
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -243,8 +239,7 @@
       IL_0034:  ret
     } 
 
-    .method public hidebysig instance void 
-            Set(int32 i) cil managed
+    .method public hidebysig instance void Set(int32 i) cil managed
     {
       
       .maxstack  8
@@ -254,8 +249,7 @@
       IL_0007:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance bool  Equals(valuetype assembly/T obj) cil managed
+    .method public hidebysig virtual final instance bool  Equals(valuetype assembly/T obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -271,8 +265,7 @@
       IL_0011:  ret
     } 
 
-    .method public hidebysig virtual final 
-            instance bool  Equals(object obj) cil managed
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       
@@ -301,8 +294,7 @@
 
   } 
 
-  .method public specialname static valuetype assembly/T[] 
-          get_a() cil managed
+  .method public specialname static valuetype assembly/T[] get_a() cil managed
   {
     
     .maxstack  8
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/StructsAsArrayElements01.fs.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/StructsAsArrayElements01.fs.RealInternalSignatureOff.il.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/StructsAsArrayElements01.fs.il.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/StructsAsArrayElements01.fs.RealInternalSignatureOff.il.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/StructsAsArrayElements01.fs.RealInternalSignatureOn.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/StructsAsArrayElements01.fs.RealInternalSignatureOn.il.debug.bsl
new file mode 100644
index 00000000000..36c41338aa7
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/StructsAsArrayElements01.fs.RealInternalSignatureOn.il.debug.bsl
@@ -0,0 +1,367 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class sequential ansi serializable sealed nested public T
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype assembly/T>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype assembly/T>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.StructAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field public int32 i
+    .method public hidebysig virtual final instance int32  CompareTo(valuetype assembly/T obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (valuetype assembly/T& V_0,
+               class [runtime]System.Collections.IComparer V_1,
+               int32 V_2,
+               int32 V_3,
+               class [runtime]System.Collections.IComparer V_4,
+               int32 V_5,
+               int32 V_6)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0008:  stloc.1
+      IL_0009:  ldarg.0
+      IL_000a:  ldfld      int32 assembly/T::i
+      IL_000f:  stloc.2
+      IL_0010:  ldloc.0
+      IL_0011:  ldfld      int32 assembly/T::i
+      IL_0016:  stloc.3
+      IL_0017:  ldloc.1
+      IL_0018:  stloc.s    V_4
+      IL_001a:  ldloc.2
+      IL_001b:  stloc.s    V_5
+      IL_001d:  ldloc.3
+      IL_001e:  stloc.s    V_6
+      IL_0020:  ldloc.s    V_5
+      IL_0022:  ldloc.s    V_6
+      IL_0024:  cgt
+      IL_0026:  ldloc.s    V_5
+      IL_0028:  ldloc.s    V_6
+      IL_002a:  clt
+      IL_002c:  sub
+      IL_002d:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  assembly/T
+      IL_0007:  call       instance int32 assembly/T::CompareTo(valuetype assembly/T)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (valuetype assembly/T V_0,
+               valuetype assembly/T& V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4,
+               class [runtime]System.Collections.IComparer V_5,
+               int32 V_6,
+               int32 V_7)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  assembly/T
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldarg.2
+      IL_000b:  stloc.2
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      int32 assembly/T::i
+      IL_0012:  stloc.3
+      IL_0013:  ldloc.1
+      IL_0014:  ldfld      int32 assembly/T::i
+      IL_0019:  stloc.s    V_4
+      IL_001b:  ldloc.2
+      IL_001c:  stloc.s    V_5
+      IL_001e:  ldloc.3
+      IL_001f:  stloc.s    V_6
+      IL_0021:  ldloc.s    V_4
+      IL_0023:  stloc.s    V_7
+      IL_0025:  ldloc.s    V_6
+      IL_0027:  ldloc.s    V_7
+      IL_0029:  cgt
+      IL_002b:  ldloc.s    V_6
+      IL_002d:  ldloc.s    V_7
+      IL_002f:  clt
+      IL_0031:  sub
+      IL_0032:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1,
+               int32 V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldc.i4.0
+      IL_0001:  stloc.0
+      IL_0002:  ldc.i4     0x9e3779b9
+      IL_0007:  ldarg.1
+      IL_0008:  stloc.1
+      IL_0009:  ldarg.0
+      IL_000a:  ldfld      int32 assembly/T::i
+      IL_000f:  stloc.2
+      IL_0010:  ldloc.1
+      IL_0011:  stloc.3
+      IL_0012:  ldloc.2
+      IL_0013:  ldloc.0
+      IL_0014:  ldc.i4.6
+      IL_0015:  shl
+      IL_0016:  ldloc.0
+      IL_0017:  ldc.i4.2
+      IL_0018:  shr
+      IL_0019:  add
+      IL_001a:  add
+      IL_001b:  add
+      IL_001c:  stloc.0
+      IL_001d:  ldloc.0
+      IL_001e:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 assembly/T::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype assembly/T V_1,
+               valuetype assembly/T& V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IEqualityComparer V_6)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     assembly/T
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_0033
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  assembly/T
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldarg.2
+      IL_0018:  stloc.3
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      int32 assembly/T::i
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.2
+      IL_0022:  ldfld      int32 assembly/T::i
+      IL_0027:  stloc.s    V_5
+      IL_0029:  ldloc.3
+      IL_002a:  stloc.s    V_6
+      IL_002c:  ldloc.s    V_4
+      IL_002e:  ldloc.s    V_5
+      IL_0030:  ceq
+      IL_0032:  ret
+
+      IL_0033:  ldc.i4.0
+      IL_0034:  ret
+    } 
+
+    .method public hidebysig instance void Set(int32 i) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 assembly/T::i
+      IL_0007:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(valuetype assembly/T obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/T& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldarg.0
+      IL_0004:  ldfld      int32 assembly/T::i
+      IL_0009:  ldloc.0
+      IL_000a:  ldfld      int32 assembly/T::i
+      IL_000f:  ceq
+      IL_0011:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype assembly/T V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     assembly/T
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  assembly/T
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool assembly/T::Equals(valuetype assembly/T)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+  } 
+
+  .field static assembly valuetype assembly/T[] a@11
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static valuetype assembly/T[] get_a() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     valuetype assembly/T[] assembly::a@11
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (valuetype assembly/T V_0)
+    IL_0000:  ldc.i4.s   10
+    IL_0002:  ldloc.0
+    IL_0003:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<valuetype assembly/T>(int32,
+                                                                                                                                   !!0)
+    IL_0008:  stsfld     valuetype assembly/T[] assembly::a@11
+    IL_000d:  call       valuetype assembly/T[] assembly::get_a()
+    IL_0012:  ldc.i4.0
+    IL_0013:  ldelema    assembly/T
+    IL_0018:  ldc.i4.s   27
+    IL_001a:  call       instance void assembly/T::Set(int32)
+    IL_001f:  nop
+    IL_0020:  ret
+  } 
+
+  .property valuetype assembly/T[]
+          a()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get valuetype assembly/T[] assembly::get_a()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/StructsAsArrayElements01.fs.RealInternalSignatureOn.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/StructsAsArrayElements01.fs.RealInternalSignatureOn.il.release.bsl
new file mode 100644
index 00000000000..0743b86a949
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/StructsAsArrayElements01.fs.RealInternalSignatureOn.il.release.bsl
@@ -0,0 +1,334 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class sequential ansi serializable sealed nested public T
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype assembly/T>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype assembly/T>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.StructAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field public int32 i
+    .method public hidebysig virtual final instance int32  CompareTo(valuetype assembly/T obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (valuetype assembly/T& V_0,
+               class [runtime]System.Collections.IComparer V_1,
+               int32 V_2,
+               int32 V_3)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0008:  stloc.1
+      IL_0009:  ldarg.0
+      IL_000a:  ldfld      int32 assembly/T::i
+      IL_000f:  stloc.2
+      IL_0010:  ldloc.0
+      IL_0011:  ldfld      int32 assembly/T::i
+      IL_0016:  stloc.3
+      IL_0017:  ldloc.2
+      IL_0018:  ldloc.3
+      IL_0019:  cgt
+      IL_001b:  ldloc.2
+      IL_001c:  ldloc.3
+      IL_001d:  clt
+      IL_001f:  sub
+      IL_0020:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  assembly/T
+      IL_0007:  call       instance int32 assembly/T::CompareTo(valuetype assembly/T)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (valuetype assembly/T V_0,
+               valuetype assembly/T& V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  assembly/T
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldarg.2
+      IL_000b:  stloc.2
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      int32 assembly/T::i
+      IL_0012:  stloc.3
+      IL_0013:  ldloc.1
+      IL_0014:  ldfld      int32 assembly/T::i
+      IL_0019:  stloc.s    V_4
+      IL_001b:  ldloc.3
+      IL_001c:  ldloc.s    V_4
+      IL_001e:  cgt
+      IL_0020:  ldloc.3
+      IL_0021:  ldloc.s    V_4
+      IL_0023:  clt
+      IL_0025:  sub
+      IL_0026:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1)
+      IL_0000:  ldc.i4.0
+      IL_0001:  stloc.0
+      IL_0002:  ldc.i4     0x9e3779b9
+      IL_0007:  ldarg.1
+      IL_0008:  stloc.1
+      IL_0009:  ldarg.0
+      IL_000a:  ldfld      int32 assembly/T::i
+      IL_000f:  ldloc.0
+      IL_0010:  ldc.i4.6
+      IL_0011:  shl
+      IL_0012:  ldloc.0
+      IL_0013:  ldc.i4.2
+      IL_0014:  shr
+      IL_0015:  add
+      IL_0016:  add
+      IL_0017:  add
+      IL_0018:  stloc.0
+      IL_0019:  ldloc.0
+      IL_001a:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 assembly/T::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype assembly/T V_1,
+               valuetype assembly/T& V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     assembly/T
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_0028
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  assembly/T
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldarg.2
+      IL_0018:  stloc.3
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      int32 assembly/T::i
+      IL_001f:  ldloc.2
+      IL_0020:  ldfld      int32 assembly/T::i
+      IL_0025:  ceq
+      IL_0027:  ret
+
+      IL_0028:  ldc.i4.0
+      IL_0029:  ret
+    } 
+
+    .method public hidebysig instance void Set(int32 i) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 assembly/T::i
+      IL_0007:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(valuetype assembly/T obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/T& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldarg.0
+      IL_0004:  ldfld      int32 assembly/T::i
+      IL_0009:  ldloc.0
+      IL_000a:  ldfld      int32 assembly/T::i
+      IL_000f:  ceq
+      IL_0011:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype assembly/T V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     assembly/T
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  assembly/T
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool assembly/T::Equals(valuetype assembly/T)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+  } 
+
+  .field static assembly valuetype assembly/T[] a@11
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static valuetype assembly/T[] get_a() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     valuetype assembly/T[] assembly::a@11
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (valuetype assembly/T V_0)
+    IL_0000:  ldc.i4.s   10
+    IL_0002:  ldloc.0
+    IL_0003:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.ArrayModule::Create<valuetype assembly/T>(int32,
+                                                                                                                                   !!0)
+    IL_0008:  stsfld     valuetype assembly/T[] assembly::a@11
+    IL_000d:  call       valuetype assembly/T[] assembly::get_a()
+    IL_0012:  ldc.i4.0
+    IL_0013:  ldelema    assembly/T
+    IL_0018:  ldc.i4.s   27
+    IL_001a:  call       instance void assembly/T::Set(int32)
+    IL_001f:  nop
+    IL_0020:  ret
+  } 
+
+  .property valuetype assembly/T[]
+          a()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get valuetype assembly/T[] assembly::get_a()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/TryWith_NoFilterBlocks01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/TryWith_NoFilterBlocks01.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/TryWith_NoFilterBlocks01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/TryWith_NoFilterBlocks01.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/TryWith_NoFilterBlocks01.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/TryWith_NoFilterBlocks01.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..35a0349ec65
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Misc/TryWith_NoFilterBlocks01.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,116 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0,
+             class [runtime]System.Exception V_1,
+             class [runtime]System.Exception V_2)
+    .try
+    {
+      IL_0000:  nop
+      IL_0001:  leave.s    IL_001c
+
+    }  
+    catch [runtime]System.Object 
+    {
+      IL_0003:  castclass  [runtime]System.Exception
+      IL_0008:  stloc.0
+      IL_0009:  ldloc.0
+      IL_000a:  stloc.1
+      IL_000b:  ldloc.1
+      IL_000c:  callvirt   instance int32 [runtime]System.Object::GetHashCode()
+      IL_0011:  ldc.i4.0
+      IL_0012:  ceq
+      IL_0014:  brfalse.s  IL_001a
+
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  leave.s    IL_001c
+
+      IL_001a:  leave.s    IL_001c
+
+    }  
+    IL_001c:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/NoCompilerInlining.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/NoCompilerInlining.fs
index f9be4e7def9..bc967c9c88d 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/NoCompilerInlining.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/NoCompilerInlining.fs
@@ -53,7 +53,7 @@ module MiddleModule
     .entrypoint
     
     .maxstack  8
-    IL_0000:  call       void [middleModule]MiddleModule::sayMiddleModuleHello()
+    IL_0000:  call       void assembly::staticInitialization@()
     IL_0005:  ret
   } 
 """ ]
@@ -101,7 +101,7 @@ module MiddleModule
     .entrypoint
     
     .maxstack  8
-    IL_0000:  call       void [middleModule]MiddleModule::sayMiddleModuleHello()
+    IL_0000:  call       void assembly::staticInitialization@()
     IL_0005:  ret
   } 
 """ ]
@@ -148,9 +148,23 @@ module MiddleModule
         |> compileExeAndRun
         |> shouldSucceed
         |> verifyIL [ """
-  .method public static void  main@() cil managed
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
   {
-    .entrypoint
     
     .maxstack  8
     IL_0000:  ldstr      "x + y: {0} + {1} = "
@@ -165,6 +179,26 @@ module MiddleModule
     IL_001b:  call       void [runtime]System.Console::WriteLine(string)
     IL_0020:  ret
   } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
 """ ]
 
 
@@ -203,15 +237,49 @@ module MiddleModule
         |> compileExeAndRun
         |> shouldSucceed
         |> verifyIL [ """
-  .method public static void  main@() cil managed
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
   {
-    .entrypoint
     
     .maxstack  8
     IL_0000:  ldstr      "Hello World"
     IL_0005:  call       void [runtime]System.Console::WriteLine(string)
     IL_000a:  ret
   } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
 """ ]
 
 
@@ -256,15 +324,49 @@ module MiddleModule
         |> compileExeAndRun
         |> shouldSucceed
         |> verifyIL [ """
-  .method public static void  main@() cil managed
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
   {
-    .entrypoint
     
     .maxstack  8
     IL_0000:  ldstr      "Hello World"
     IL_0005:  call       void [runtime]System.Console::WriteLine(string)
     IL_000a:  ret
   } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
 """ ]
 
     [<Fact>]
@@ -305,15 +407,49 @@ module MiddleModule
         |> compileExeAndRun
         |> shouldSucceed
         |> verifyIL [ """
-  .method public static void  main@() cil managed
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
   {
-    .entrypoint
     
     .maxstack  8
     IL_0000:  ldstr      "Hello World"
     IL_0005:  call       void [runtime]System.Console::WriteLine(string)
     IL_000a:  ret
   } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
 """ ]
 
 
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOff.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOff.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOff.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOff.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOff.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOff.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOn.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOn.il.net472.debug.bsl
new file mode 100644
index 00000000000..9f2155759bf
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOn.il.net472.debug.bsl
@@ -0,0 +1,7117 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern System.Core
+{
+  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         
+  .ver 4:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 11@12'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_factorsOf300()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 11@12'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname numSum@21
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/numSum@21::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/numSum@21::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/numSum@21::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/numSum@21::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/numSum@21::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/numSum@21::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/numSum@21::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/numSum@21::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/numSum@21::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/numSum@21::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/numSum@21::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/numSum@21::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/numSum@21::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/numSum@21::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/numSum@21::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/numSum@21::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/numSum@21::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                              int32,
+                                                                              int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'numSum@22-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'numSum@22-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'numSum@22-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'numSum@22-1' assembly/'numSum@22-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname totalChars@30
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/totalChars@30::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/totalChars@30::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/totalChars@30::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/totalChars@30::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/totalChars@30::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/totalChars@30::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/totalChars@30::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/totalChars@30::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/totalChars@30::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/totalChars@30::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/totalChars@30::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/totalChars@30::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/totalChars@30::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/totalChars@30::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/totalChars@30::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/totalChars@30::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/totalChars@30::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                  int32,
+                                                                                  string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'totalChars@31-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'totalChars@31-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'totalChars@31-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'totalChars@31-1' assembly/'totalChars@31-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@39'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@39'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@39'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@40-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@40-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@40-1' assembly/'Pipe #2 input at line 38@40-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@40-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@40-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@40-2' assembly/'Pipe #2 input at line 38@40-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname sum@42
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/sum@42::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/sum@42::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/sum@42::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/sum@42::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/sum@42::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/sum@42::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/sum@42::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/sum@42::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/sum@42::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/sum@42::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/sum@42::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/sum@42::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/sum@42::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/sum@42::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/sum@42::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/sum@42::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/sum@42::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/sum@42::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/sum@42::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/sum@42::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                           int32,
+                                                                           class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'sum@43-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>
+  {
+    .field static assembly initonly class assembly/'sum@43-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'sum@43-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'sum@43-1' assembly/'sum@43-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@40-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               int32 V_1,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable> V_4,
+               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32> V_5,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_6,
+               class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> V_7,
+               int32 V_8,
+               int32 V_9,
+               class [runtime]System.IDisposable V_10)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  stloc.2
+      IL_0008:  ldloc.2
+      IL_0009:  stloc.3
+      IL_000a:  ldloc.0
+      IL_000b:  ldnull
+      IL_000c:  ldc.i4.0
+      IL_000d:  ldnull
+      IL_000e:  newobj     instance void assembly/sum@42::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                           int32,
+                                                                           class [Utils]Utils/Product)
+      IL_0013:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0018:  stloc.s    V_4
+      IL_001a:  ldsfld     class assembly/'sum@43-1' assembly/'sum@43-1'::@_instance
+      IL_001f:  stloc.s    V_5
+      IL_0021:  ldloc.s    V_4
+      IL_0023:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_0028:  stloc.s    V_6
+      IL_002a:  ldloc.s    V_6
+      IL_002c:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0031:  stloc.s    V_7
+      .try
+      {
+        IL_0033:  ldc.i4.0
+        IL_0034:  stloc.s    V_9
+        IL_0036:  br.s       IL_004b
+
+        IL_0038:  ldloc.s    V_9
+        IL_003a:  ldloc.s    V_5
+        IL_003c:  ldloc.s    V_7
+        IL_003e:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+        IL_0043:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>::Invoke(!0)
+        IL_0048:  add.ovf
+        IL_0049:  stloc.s    V_9
+        IL_004b:  ldloc.s    V_7
+        IL_004d:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+        IL_0052:  brtrue.s   IL_0038
+
+        IL_0054:  ldloc.s    V_9
+        IL_0056:  stloc.s    V_8
+        IL_0058:  leave.s    IL_0070
+
+      }  
+      finally
+      {
+        IL_005a:  ldloc.s    V_7
+        IL_005c:  isinst     [runtime]System.IDisposable
+        IL_0061:  stloc.s    V_10
+        IL_0063:  ldloc.s    V_10
+        IL_0065:  brfalse.s  IL_006f
+
+        IL_0067:  ldloc.s    V_10
+        IL_0069:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+        IL_006e:  endfinally
+        IL_006f:  endfinally
+      }  
+      IL_0070:  ldloc.s    V_8
+      IL_0072:  stloc.1
+      IL_0073:  ldarg.0
+      IL_0074:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@40-3'::builder@
+      IL_0079:  ldloc.0
+      IL_007a:  ldloc.1
+      IL_007b:  newobj     instance void class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>::.ctor(!0,
+                                                                                                                                                                    !1)
+      IL_0080:  tail.
+      IL_0082:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object>(!!0)
+      IL_0087:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@45-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,class [runtime]System.Tuple`2<string,int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@45-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,class [runtime]System.Tuple`2<string,int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,int32> Invoke(class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               int32 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,int32>::.ctor(!0,
+                                                                                             !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@45-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@45-4' assembly/'Pipe #2 input at line 38@45-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname minNum@49
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/minNum@49::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/minNum@49::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/minNum@49::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/minNum@49::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/minNum@49::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/minNum@49::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/minNum@49::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/minNum@49::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/minNum@49::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/minNum@49::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/minNum@49::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/minNum@49::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/minNum@49::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/minNum@49::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/minNum@49::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/minNum@49::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/minNum@49::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                              int32,
+                                                                              int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'minNum@49-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'minNum@49-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'minNum@49-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'minNum@49-1' assembly/'minNum@49-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname shortestWord@52
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/shortestWord@52::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/shortestWord@52::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/shortestWord@52::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/shortestWord@52::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/shortestWord@52::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/shortestWord@52::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/shortestWord@52::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/shortestWord@52::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/shortestWord@52::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/shortestWord@52::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/shortestWord@52::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/shortestWord@52::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/shortestWord@52::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/shortestWord@52::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/shortestWord@52::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/shortestWord@52::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/shortestWord@52::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                    int32,
+                                                                                    string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'shortestWord@52-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'shortestWord@52-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'shortestWord@52-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'shortestWord@52-1' assembly/'shortestWord@52-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@57'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 56@57'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 56@57'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@58-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 56@58-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 56@58-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 56@58-1' assembly/'Pipe #3 input at line 56@58-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@58-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 56@58-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 56@58-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 56@58-2' assembly/'Pipe #3 input at line 56@58-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname min@59
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/min@59::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/min@59::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/min@59::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/min@59::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/min@59::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/min@59::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/min@59::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/min@59::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/min@59::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/min@59::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/min@59::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/min@59::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/min@59::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/min@59::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/min@59::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/min@59::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/min@59::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/min@59::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/min@59::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/min@59::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                           int32,
+                                                                           class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'min@59-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'min@59-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'min@59-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'min@59-1' assembly/'min@59-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@58-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 56@58-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  ldloc.0
+      IL_0008:  ldnull
+      IL_0009:  ldc.i4.0
+      IL_000a:  ldnull
+      IL_000b:  newobj     instance void assembly/min@59::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                           int32,
+                                                                           class [Utils]Utils/Product)
+      IL_0010:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0015:  ldsfld     class assembly/'min@59-1' assembly/'min@59-1'::@_instance
+      IL_001a:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MinBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,valuetype [runtime]System.Decimal>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_001f:  stloc.1
+      IL_0020:  ldarg.0
+      IL_0021:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 56@58-3'::builder@
+      IL_0026:  ldloc.0
+      IL_0027:  ldloc.1
+      IL_0028:  newobj     instance void class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                                                                                 !1)
+      IL_002d:  tail.
+      IL_002f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(!!0)
+      IL_0034:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@60-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 56@60-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                          !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 56@60-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 56@60-4' assembly/'Pipe #3 input at line 56@60-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@66'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 65@66'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 65@66'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@67-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 65@67-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 65@67-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 65@67-1' assembly/'Pipe #4 input at line 65@67-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@67-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 65@67-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 65@67-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 65@67-2' assembly/'Pipe #4 input at line 65@67-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class abstract auto autochar serializable sealed nested assembly beforefieldinit specialname 'min@68-2'
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method assembly static valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname cheapestProducts@69
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/cheapestProducts@69::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/cheapestProducts@69::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/cheapestProducts@69::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/cheapestProducts@69::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/cheapestProducts@69::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/cheapestProducts@69::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/cheapestProducts@69::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/cheapestProducts@69::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/cheapestProducts@69::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/cheapestProducts@69::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                        class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                        int32,
+                                                                                        class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'cheapestProducts@69-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field public valuetype [runtime]System.Decimal min
+    .method assembly specialname rtspecialname instance void  .ctor(valuetype [runtime]System.Decimal min) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      valuetype [runtime]System.Decimal assembly/'cheapestProducts@69-1'::min
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0006:  ldarg.0
+      IL_0007:  ldfld      valuetype [runtime]System.Decimal assembly/'cheapestProducts@69-1'::min
+      IL_000c:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                         valuetype [netstandard]System.Decimal)
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@67-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 65@67-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_2,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  ldnull
+      IL_0004:  ldftn      valuetype [runtime]System.Decimal assembly/'min@68-2'::Invoke(class [Utils]Utils/Product)
+      IL_000a:  newobj     instance void class [runtime]System.Func`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor(object,
+                                                                                                                                             native int)
+      IL_000f:  call       valuetype [runtime]System.Decimal [System.Core]System.Linq.Enumerable::Min<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                                                   class [runtime]System.Func`2<!!0,valuetype [runtime]System.Decimal>)
+      IL_0014:  stloc.1
+      IL_0015:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_001a:  stloc.3
+      IL_001b:  ldloc.3
+      IL_001c:  ldloc.0
+      IL_001d:  ldnull
+      IL_001e:  ldc.i4.0
+      IL_001f:  ldnull
+      IL_0020:  newobj     instance void assembly/cheapestProducts@69::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                        class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                        int32,
+                                                                                        class [Utils]Utils/Product)
+      IL_0025:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_002a:  ldloc.1
+      IL_002b:  newobj     instance void assembly/'cheapestProducts@69-1'::.ctor(valuetype [runtime]System.Decimal)
+      IL_0030:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_003a:  stloc.2
+      IL_003b:  ldarg.0
+      IL_003c:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 65@67-3'::builder@
+      IL_0041:  ldloc.0
+      IL_0042:  ldloc.1
+      IL_0043:  ldloc.2
+      IL_0044:  newobj     instance void class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                                                                                                                      !1,
+                                                                                                                                                                                                                                                                                      !2)
+      IL_0049:  tail.
+      IL_004b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(!!0)
+      IL_0050:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@70-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 65@70-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> Invoke(class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldarg.1
+      IL_000f:  call       instance !2 class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item3()
+      IL_0014:  stloc.2
+      IL_0015:  ldloc.0
+      IL_0016:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_001b:  ldloc.2
+      IL_001c:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                            !1)
+      IL_0021:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 65@70-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 65@70-4' assembly/'Pipe #4 input at line 65@70-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname maxNum@74
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/maxNum@74::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/maxNum@74::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxNum@74::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/maxNum@74::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/maxNum@74::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/maxNum@74::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/maxNum@74::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/maxNum@74::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/maxNum@74::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxNum@74::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/maxNum@74::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/maxNum@74::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/maxNum@74::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/maxNum@74::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxNum@74::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxNum@74::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/maxNum@74::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                              int32,
+                                                                              int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'maxNum@74-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'maxNum@74-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'maxNum@74-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'maxNum@74-1' assembly/'maxNum@74-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname longestLength@77
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/longestLength@77::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/longestLength@77::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/longestLength@77::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/longestLength@77::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/longestLength@77::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/longestLength@77::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/longestLength@77::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/longestLength@77::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/longestLength@77::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/longestLength@77::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/longestLength@77::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/longestLength@77::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/longestLength@77::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/longestLength@77::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/longestLength@77::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/longestLength@77::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/longestLength@77::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                     int32,
+                                                                                     string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'longestLength@77-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'longestLength@77-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'longestLength@77-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'longestLength@77-1' assembly/'longestLength@77-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@82'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #5 input at line 81@82'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #5 input at line 81@82'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@83-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 81@83-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 81@83-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 81@83-1' assembly/'Pipe #5 input at line 81@83-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@83-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 81@83-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 81@83-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 81@83-2' assembly/'Pipe #5 input at line 81@83-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname mostExpensivePrice@84
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensivePrice@84::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensivePrice@84::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/mostExpensivePrice@84::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/mostExpensivePrice@84::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/mostExpensivePrice@84::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensivePrice@84::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/mostExpensivePrice@84::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                          class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                          int32,
+                                                                                          class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'mostExpensivePrice@84-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'mostExpensivePrice@84-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'mostExpensivePrice@84-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'mostExpensivePrice@84-1' assembly/'mostExpensivePrice@84-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@83-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #5 input at line 81@83-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  ldloc.0
+      IL_0008:  ldnull
+      IL_0009:  ldc.i4.0
+      IL_000a:  ldnull
+      IL_000b:  newobj     instance void assembly/mostExpensivePrice@84::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                          class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                          int32,
+                                                                                          class [Utils]Utils/Product)
+      IL_0010:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0015:  ldsfld     class assembly/'mostExpensivePrice@84-1' assembly/'mostExpensivePrice@84-1'::@_instance
+      IL_001a:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MaxBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,valuetype [runtime]System.Decimal>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_001f:  stloc.1
+      IL_0020:  ldarg.0
+      IL_0021:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #5 input at line 81@83-3'::builder@
+      IL_0026:  ldloc.0
+      IL_0027:  ldloc.1
+      IL_0028:  newobj     instance void class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                                                                                 !1)
+      IL_002d:  tail.
+      IL_002f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(!!0)
+      IL_0034:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@85-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 81@85-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                          !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 81@85-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 81@85-4' assembly/'Pipe #5 input at line 81@85-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@91'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 90@91'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 90@91'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@92-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 90@92-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 90@92-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 90@92-1' assembly/'Pipe #6 input at line 90@92-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@92-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 90@92-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 90@92-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 90@92-2' assembly/'Pipe #6 input at line 90@92-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname maxPrice@93
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/maxPrice@93::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/maxPrice@93::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxPrice@93::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/maxPrice@93::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/maxPrice@93::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/maxPrice@93::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/maxPrice@93::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/maxPrice@93::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxPrice@93::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/maxPrice@93::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/maxPrice@93::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/maxPrice@93::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxPrice@93::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/maxPrice@93::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/maxPrice@93::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                int32,
+                                                                                class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'maxPrice@93-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'maxPrice@93-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'maxPrice@93-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'maxPrice@93-1' assembly/'maxPrice@93-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname mostExpensiveProducts@94
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/mostExpensiveProducts@94::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/mostExpensiveProducts@94::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                             class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                             int32,
+                                                                                             class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'mostExpensiveProducts@94-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field public valuetype [runtime]System.Decimal maxPrice
+    .method assembly specialname rtspecialname instance void  .ctor(valuetype [runtime]System.Decimal maxPrice) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      valuetype [runtime]System.Decimal assembly/'mostExpensiveProducts@94-1'::maxPrice
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0006:  ldarg.0
+      IL_0007:  ldfld      valuetype [runtime]System.Decimal assembly/'mostExpensiveProducts@94-1'::maxPrice
+      IL_000c:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                         valuetype [netstandard]System.Decimal)
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@92-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 90@92-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_2,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  ldloc.0
+      IL_0008:  ldnull
+      IL_0009:  ldc.i4.0
+      IL_000a:  ldnull
+      IL_000b:  newobj     instance void assembly/maxPrice@93::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                int32,
+                                                                                class [Utils]Utils/Product)
+      IL_0010:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0015:  ldsfld     class assembly/'maxPrice@93-1' assembly/'maxPrice@93-1'::@_instance
+      IL_001a:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MaxBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,valuetype [runtime]System.Decimal>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_001f:  stloc.1
+      IL_0020:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0025:  stloc.3
+      IL_0026:  ldloc.3
+      IL_0027:  ldloc.0
+      IL_0028:  ldnull
+      IL_0029:  ldc.i4.0
+      IL_002a:  ldnull
+      IL_002b:  newobj     instance void assembly/mostExpensiveProducts@94::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                             class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                             int32,
+                                                                                             class [Utils]Utils/Product)
+      IL_0030:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0035:  ldloc.1
+      IL_0036:  newobj     instance void assembly/'mostExpensiveProducts@94-1'::.ctor(valuetype [runtime]System.Decimal)
+      IL_003b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+      IL_0040:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_0045:  stloc.2
+      IL_0046:  ldarg.0
+      IL_0047:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 90@92-3'::builder@
+      IL_004c:  ldloc.0
+      IL_004d:  ldloc.1
+      IL_004e:  ldloc.2
+      IL_004f:  newobj     instance void class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                                                                                                                      !1,
+                                                                                                                                                                                                                                                                                      !2)
+      IL_0054:  tail.
+      IL_0056:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(!!0)
+      IL_005b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@95-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 90@95-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> Invoke(class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldarg.1
+      IL_000f:  call       instance !2 class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item3()
+      IL_0014:  stloc.2
+      IL_0015:  ldloc.0
+      IL_0016:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_001b:  ldloc.2
+      IL_001c:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                            !1)
+      IL_0021:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 90@95-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 90@95-4' assembly/'Pipe #6 input at line 90@95-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname averageNum@100
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<float64>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<float64> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public float64 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<float64> 'enum',
+                                 int32 pc,
+                                 float64 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/averageNum@100::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      float64 assembly/averageNum@100::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<float64>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<float64>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (float64 V_0,
+               float64 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averageNum@100::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> assembly::get_numbers2()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<float64>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/averageNum@100::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<float64>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/averageNum@100::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      float64 assembly/averageNum@100::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/averageNum@100::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<float64>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/averageNum@100::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.r8     0.0
+      IL_0095:  stfld      float64 assembly/averageNum@100::current
+      IL_009a:  ldc.i4.0
+      IL_009b:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averageNum@100::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_007e
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/averageNum@100::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/averageNum@100::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<float64>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/averageNum@100::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.r8     0.0
+        IL_0067:  stfld      float64 assembly/averageNum@100::current
+        IL_006c:  leave.s    IL_0078
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_006e:  castclass  [runtime]System.Exception
+        IL_0073:  stloc.1
+        IL_0074:  ldloc.1
+        IL_0075:  stloc.0
+        IL_0076:  leave.s    IL_0078
+
+      }  
+      IL_0078:  nop
+      IL_0079:  br         IL_0000
+
+      IL_007e:  ldloc.0
+      IL_007f:  brfalse.s  IL_0083
+
+      IL_0081:  ldloc.0
+      IL_0082:  throw
+
+      IL_0083:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averageNum@100::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance float64 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      float64 assembly/averageNum@100::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<float64> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.r8     0.0
+      IL_000b:  newobj     instance void assembly/averageNum@100::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<float64>,
+                                                                                   int32,
+                                                                                   float64)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'averageNum@100-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,float64>
+  {
+    .field static assembly initonly class assembly/'averageNum@100-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,float64>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance float64 Invoke(float64 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'averageNum@100-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'averageNum@100-1' assembly/'averageNum@100-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit averageLength@105
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/averageLength@105::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,object> Invoke(string _arg1) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (string V_0,
+               float64 V_1,
+               int32 V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0008:  stloc.2
+      IL_0009:  ldloc.2
+      IL_000a:  conv.r8
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/averageLength@105::builder@
+      IL_0012:  ldloc.0
+      IL_0013:  ldloc.1
+      IL_0014:  newobj     instance void class [runtime]System.Tuple`2<string,float64>::.ctor(!0,
+                                                                                               !1)
+      IL_0019:  tail.
+      IL_001b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<string,float64>,object>(!!0)
+      IL_0020:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'averageLength@107-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,float64>,float64>
+  {
+    .field static assembly initonly class assembly/'averageLength@107-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,float64>,float64>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance float64 Invoke(class [runtime]System.Tuple`2<string,float64> tupledArg) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (string V_0,
+               float64 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<string,float64>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<string,float64>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'averageLength@107-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'averageLength@107-1' assembly/'averageLength@107-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@113'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 112@113'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 112@113'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@114-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 112@114-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 112@114-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 112@114-1' assembly/'Pipe #7 input at line 112@114-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@114-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 112@114-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 112@114-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 112@114-2' assembly/'Pipe #7 input at line 112@114-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname averagePrice@115
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/averagePrice@115::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/averagePrice@115::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averagePrice@115::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/averagePrice@115::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/averagePrice@115::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/averagePrice@115::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/averagePrice@115::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/averagePrice@115::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averagePrice@115::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/averagePrice@115::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/averagePrice@115::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/averagePrice@115::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averagePrice@115::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/averagePrice@115::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/averagePrice@115::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                     class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                     int32,
+                                                                                     class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'averagePrice@115-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'averagePrice@115-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'averagePrice@115-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'averagePrice@115-1' assembly/'averagePrice@115-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@114-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 112@114-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable> V_4,
+               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal> V_5,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_6,
+               string V_7,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_8,
+               string V_9,
+               class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> V_10,
+               valuetype [runtime]System.Decimal V_11,
+               valuetype [runtime]System.Decimal V_12,
+               int32 V_13,
+               string V_14,
+               valuetype [runtime]System.Decimal V_15,
+               int32 V_16,
+               class [runtime]System.IDisposable V_17)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  stloc.2
+      IL_0008:  ldloc.2
+      IL_0009:  stloc.3
+      IL_000a:  ldloc.0
+      IL_000b:  ldnull
+      IL_000c:  ldc.i4.0
+      IL_000d:  ldnull
+      IL_000e:  newobj     instance void assembly/averagePrice@115::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                     class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                     int32,
+                                                                                     class [Utils]Utils/Product)
+      IL_0013:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0018:  stloc.s    V_4
+      IL_001a:  ldsfld     class assembly/'averagePrice@115-1' assembly/'averagePrice@115-1'::@_instance
+      IL_001f:  stloc.s    V_5
+      IL_0021:  ldloc.s    V_4
+      IL_0023:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_0028:  stloc.s    V_6
+      IL_002a:  ldstr      "source"
+      IL_002f:  stloc.s    V_7
+      IL_0031:  ldloc.s    V_6
+      IL_0033:  stloc.s    V_8
+      IL_0035:  ldloc.s    V_8
+      IL_0037:  box        class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>
+      IL_003c:  brtrue.s   IL_004a
+
+      IL_003e:  ldloc.s    V_7
+      IL_0040:  stloc.s    V_9
+      IL_0042:  ldloc.s    V_9
+      IL_0044:  newobj     instance void [netstandard]System.ArgumentNullException::.ctor(string)
+      IL_0049:  throw
+
+      IL_004a:  nop
+      IL_004b:  ldloc.s    V_6
+      IL_004d:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0052:  stloc.s    V_10
+      .try
+      {
+        IL_0054:  ldc.i4.0
+        IL_0055:  ldc.i4.0
+        IL_0056:  ldc.i4.0
+        IL_0057:  ldc.i4.0
+        IL_0058:  ldc.i4.0
+        IL_0059:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                              int32,
+                                                                              int32,
+                                                                              bool,
+                                                                              uint8)
+        IL_005e:  stloc.s    V_12
+        IL_0060:  ldc.i4.0
+        IL_0061:  stloc.s    V_13
+        IL_0063:  br.s       IL_0082
+
+        IL_0065:  ldloc.s    V_12
+        IL_0067:  ldloc.s    V_5
+        IL_0069:  ldloc.s    V_10
+        IL_006b:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+        IL_0070:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::Invoke(!0)
+        IL_0075:  call       valuetype [netstandard]System.Decimal [netstandard]System.Decimal::op_Addition(valuetype [netstandard]System.Decimal,
+                                                                                                            valuetype [netstandard]System.Decimal)
+        IL_007a:  stloc.s    V_12
+        IL_007c:  ldloc.s    V_13
+        IL_007e:  ldc.i4.1
+        IL_007f:  add
+        IL_0080:  stloc.s    V_13
+        IL_0082:  ldloc.s    V_10
+        IL_0084:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+        IL_0089:  brtrue.s   IL_0065
+
+        IL_008b:  ldloc.s    V_13
+        IL_008d:  brtrue.s   IL_009e
+
+        IL_008f:  ldstr      "source"
+        IL_0094:  stloc.s    V_14
+        IL_0096:  ldloc.s    V_14
+        IL_0098:  newobj     instance void [netstandard]System.InvalidOperationException::.ctor(string)
+        IL_009d:  throw
+
+        IL_009e:  nop
+        IL_009f:  ldloc.s    V_12
+        IL_00a1:  stloc.s    V_15
+        IL_00a3:  ldloc.s    V_13
+        IL_00a5:  stloc.s    V_16
+        IL_00a7:  ldloc.s    V_15
+        IL_00a9:  ldloc.s    V_16
+        IL_00ab:  call       valuetype [netstandard]System.Decimal [netstandard]System.Convert::ToDecimal(int32)
+        IL_00b0:  call       valuetype [netstandard]System.Decimal [netstandard]System.Decimal::Divide(valuetype [netstandard]System.Decimal,
+                                                                                                       valuetype [netstandard]System.Decimal)
+        IL_00b5:  stloc.s    V_11
+        IL_00b7:  leave.s    IL_00cf
+
+      }  
+      finally
+      {
+        IL_00b9:  ldloc.s    V_10
+        IL_00bb:  isinst     [runtime]System.IDisposable
+        IL_00c0:  stloc.s    V_17
+        IL_00c2:  ldloc.s    V_17
+        IL_00c4:  brfalse.s  IL_00ce
+
+        IL_00c6:  ldloc.s    V_17
+        IL_00c8:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+        IL_00cd:  endfinally
+        IL_00ce:  endfinally
+      }  
+      IL_00cf:  ldloc.s    V_11
+      IL_00d1:  stloc.1
+      IL_00d2:  ldarg.0
+      IL_00d3:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 112@114-3'::builder@
+      IL_00d8:  ldloc.0
+      IL_00d9:  ldloc.1
+      IL_00da:  newobj     instance void class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                                                                                 !1)
+      IL_00df:  tail.
+      IL_00e1:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(!!0)
+      IL_00e6:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@116-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 112@116-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                          !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 112@116-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 112@116-4' assembly/'Pipe #7 input at line 112@116-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> factorsOf300@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 uniqueFactors@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 numSum@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@26
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 totalChars@28
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@35
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,int32>[] categories@37
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 minNum@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 shortestWord@52
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] categories2@55
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] categories3@64
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 maxNum@74
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 longestLength@77
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] categories4@80
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] categories5@89
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> numbers2@99
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly float64 averageNum@100
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly float64 averageLength@103
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] categories6@111
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_factorsOf300() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::factorsOf300@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_uniqueFactors() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::uniqueFactors@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@17
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_numSum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::numSum@19
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@26
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_totalChars() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::totalChars@28
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@35
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,int32>[] get_categories() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,int32>[] assembly::categories@37
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_minNum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::minNum@49
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_shortestWord() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::shortestWord@52
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] get_categories2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories2@55
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] get_categories3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::categories3@64
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_maxNum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::maxNum@74
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_longestLength() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::longestLength@77
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] get_categories4() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories4@80
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] get_categories5() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::categories5@89
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> get_numbers2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> assembly::numbers2@99
+    IL_0005:  ret
+  } 
+
+  .method public specialname static float64 get_averageNum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     float64 assembly::averageNum@100
+    IL_0005:  ret
+  } 
+
+  .method public specialname static float64 get_averageLength() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     float64 assembly::averageLength@103
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] get_categories6() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories6@111
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32> V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_6,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_7,
+             int32 V_8,
+             int32 V_9,
+             class [runtime]System.IDisposable V_10,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_11,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_12,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable> V_13,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32> V_14,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_15,
+             class [runtime]System.Collections.Generic.IEnumerator`1<string> V_16,
+             int32 V_17,
+             int32 V_18,
+             class [runtime]System.IDisposable V_19,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> V_20,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_21,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>> V_22,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_23,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>> V_24,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_25,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>> V_26,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_27,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>> V_28,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_29,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_30,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_31,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<float64,class [runtime]System.Collections.IEnumerable> V_32,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,float64> V_33,
+             class [runtime]System.Collections.Generic.IEnumerable`1<float64> V_34,
+             string V_35,
+             class [runtime]System.Collections.Generic.IEnumerable`1<float64> V_36,
+             string V_37,
+             class [runtime]System.Collections.Generic.IEnumerator`1<float64> V_38,
+             float64 V_39,
+             float64 V_40,
+             int32 V_41,
+             string V_42,
+             float64 V_43,
+             int32 V_44,
+             class [runtime]System.IDisposable V_45,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_46,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_47,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,class [runtime]System.Collections.IEnumerable> V_48,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,float64>,float64> V_49,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,float64>> V_50,
+             string V_51,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,float64>> V_52,
+             string V_53,
+             class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<string,float64>> V_54,
+             float64 V_55,
+             float64 V_56,
+             int32 V_57,
+             string V_58,
+             float64 V_59,
+             int32 V_60,
+             class [runtime]System.IDisposable V_61,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>> V_62,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_63)
+    IL_0000:  ldc.i4.2
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  ldc.i4.5
+    IL_0004:  ldc.i4.5
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::factorsOf300@8
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_002d:  stloc.1
+    IL_002e:  ldloc.1
+    IL_002f:  ldnull
+    IL_0030:  ldc.i4.0
+    IL_0031:  ldc.i4.0
+    IL_0032:  newobj     instance void assembly/'Pipe #1 input at line 11@12'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                int32,
+                                                                                                int32)
+    IL_0037:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_003c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Distinct<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_0041:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0046:  stloc.0
+    IL_0047:  ldloc.0
+    IL_0048:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_004d:  stsfld     int32 assembly::uniqueFactors@10
+    IL_0052:  ldc.i4.5
+    IL_0053:  ldc.i4.4
+    IL_0054:  ldc.i4.1
+    IL_0055:  ldc.i4.3
+    IL_0056:  ldc.i4.s   9
+    IL_0058:  ldc.i4.8
+    IL_0059:  ldc.i4.6
+    IL_005a:  ldc.i4.7
+    IL_005b:  ldc.i4.2
+    IL_005c:  ldc.i4.0
+    IL_005d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0062:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0067:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_006c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0071:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0076:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_007b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0080:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0085:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_008a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_008f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0094:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@17
+    IL_0099:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_009e:  stloc.2
+    IL_009f:  ldloc.2
+    IL_00a0:  stloc.3
+    IL_00a1:  ldnull
+    IL_00a2:  ldc.i4.0
+    IL_00a3:  ldc.i4.0
+    IL_00a4:  newobj     instance void assembly/numSum@21::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                            int32,
+                                                                            int32)
+    IL_00a9:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00ae:  stloc.s    V_4
+    IL_00b0:  ldsfld     class assembly/'numSum@22-1' assembly/'numSum@22-1'::@_instance
+    IL_00b5:  stloc.s    V_5
+    IL_00b7:  ldloc.s    V_4
+    IL_00b9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00be:  stloc.s    V_6
+    IL_00c0:  ldloc.s    V_6
+    IL_00c2:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_00c7:  stloc.s    V_7
+    .try
+    {
+      IL_00c9:  ldc.i4.0
+      IL_00ca:  stloc.s    V_9
+      IL_00cc:  br.s       IL_00e1
+
+      IL_00ce:  ldloc.s    V_9
+      IL_00d0:  ldloc.s    V_5
+      IL_00d2:  ldloc.s    V_7
+      IL_00d4:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_00d9:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::Invoke(!0)
+      IL_00de:  add.ovf
+      IL_00df:  stloc.s    V_9
+      IL_00e1:  ldloc.s    V_7
+      IL_00e3:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+      IL_00e8:  brtrue.s   IL_00ce
+
+      IL_00ea:  ldloc.s    V_9
+      IL_00ec:  stloc.s    V_8
+      IL_00ee:  leave.s    IL_0106
+
+    }  
+    finally
+    {
+      IL_00f0:  ldloc.s    V_7
+      IL_00f2:  isinst     [runtime]System.IDisposable
+      IL_00f7:  stloc.s    V_10
+      IL_00f9:  ldloc.s    V_10
+      IL_00fb:  brfalse.s  IL_0105
+
+      IL_00fd:  ldloc.s    V_10
+      IL_00ff:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+      IL_0104:  endfinally
+      IL_0105:  endfinally
+    }  
+    IL_0106:  ldloc.s    V_8
+    IL_0108:  stsfld     int32 assembly::numSum@19
+    IL_010d:  ldstr      "cherry"
+    IL_0112:  ldstr      "apple"
+    IL_0117:  ldstr      "blueberry"
+    IL_011c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0121:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0126:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_012b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0130:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@26
+    IL_0135:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_013a:  stloc.s    V_11
+    IL_013c:  ldloc.s    V_11
+    IL_013e:  stloc.s    V_12
+    IL_0140:  ldnull
+    IL_0141:  ldc.i4.0
+    IL_0142:  ldnull
+    IL_0143:  newobj     instance void assembly/totalChars@30::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                int32,
+                                                                                string)
+    IL_0148:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_014d:  stloc.s    V_13
+    IL_014f:  ldsfld     class assembly/'totalChars@31-1' assembly/'totalChars@31-1'::@_instance
+    IL_0154:  stloc.s    V_14
+    IL_0156:  ldloc.s    V_13
+    IL_0158:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_015d:  stloc.s    V_15
+    IL_015f:  ldloc.s    V_15
+    IL_0161:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+    IL_0166:  stloc.s    V_16
+    .try
+    {
+      IL_0168:  ldc.i4.0
+      IL_0169:  stloc.s    V_18
+      IL_016b:  br.s       IL_0180
+
+      IL_016d:  ldloc.s    V_18
+      IL_016f:  ldloc.s    V_14
+      IL_0171:  ldloc.s    V_16
+      IL_0173:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_0178:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::Invoke(!0)
+      IL_017d:  add.ovf
+      IL_017e:  stloc.s    V_18
+      IL_0180:  ldloc.s    V_16
+      IL_0182:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+      IL_0187:  brtrue.s   IL_016d
+
+      IL_0189:  ldloc.s    V_18
+      IL_018b:  stloc.s    V_17
+      IL_018d:  leave.s    IL_01a5
+
+    }  
+    finally
+    {
+      IL_018f:  ldloc.s    V_16
+      IL_0191:  isinst     [runtime]System.IDisposable
+      IL_0196:  stloc.s    V_19
+      IL_0198:  ldloc.s    V_19
+      IL_019a:  brfalse.s  IL_01a4
+
+      IL_019c:  ldloc.s    V_19
+      IL_019e:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+      IL_01a3:  endfinally
+      IL_01a4:  endfinally
+    }  
+    IL_01a5:  ldloc.s    V_17
+    IL_01a7:  stsfld     int32 assembly::totalChars@28
+    IL_01ac:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_01b1:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@35
+    IL_01b6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_01bb:  stloc.s    V_21
+    IL_01bd:  ldloc.s    V_21
+    IL_01bf:  ldloc.s    V_21
+    IL_01c1:  ldloc.s    V_21
+    IL_01c3:  ldloc.s    V_21
+    IL_01c5:  ldloc.s    V_21
+    IL_01c7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_01cc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01d1:  ldloc.s    V_21
+    IL_01d3:  newobj     instance void assembly/'Pipe #2 input at line 38@39'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01dd:  ldsfld     class assembly/'Pipe #2 input at line 38@40-1' assembly/'Pipe #2 input at line 38@40-1'::@_instance
+    IL_01e2:  ldsfld     class assembly/'Pipe #2 input at line 38@40-2' assembly/'Pipe #2 input at line 38@40-2'::@_instance
+    IL_01e7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_01ec:  ldloc.s    V_21
+    IL_01ee:  newobj     instance void assembly/'Pipe #2 input at line 38@40-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01f3:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01f8:  ldsfld     class assembly/'Pipe #2 input at line 38@45-4' assembly/'Pipe #2 input at line 38@45-4'::@_instance
+    IL_01fd:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,int32>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0202:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,int32>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0207:  stloc.s    V_20
+    IL_0209:  ldloc.s    V_20
+    IL_020b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,int32>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0210:  stsfld     class [runtime]System.Tuple`2<string,int32>[] assembly::categories@37
+    IL_0215:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_021a:  ldnull
+    IL_021b:  ldc.i4.0
+    IL_021c:  ldc.i4.0
+    IL_021d:  newobj     instance void assembly/minNum@49::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                            int32,
+                                                                            int32)
+    IL_0222:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0227:  ldsfld     class assembly/'minNum@49-1' assembly/'minNum@49-1'::@_instance
+    IL_022c:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MinBy<int32,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0231:  stsfld     int32 assembly::minNum@49
+    IL_0236:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_023b:  ldnull
+    IL_023c:  ldc.i4.0
+    IL_023d:  ldnull
+    IL_023e:  newobj     instance void assembly/shortestWord@52::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                  int32,
+                                                                                  string)
+    IL_0243:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0248:  ldsfld     class assembly/'shortestWord@52-1' assembly/'shortestWord@52-1'::@_instance
+    IL_024d:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MinBy<string,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0252:  stsfld     int32 assembly::shortestWord@52
+    IL_0257:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_025c:  stloc.s    V_23
+    IL_025e:  ldloc.s    V_23
+    IL_0260:  ldloc.s    V_23
+    IL_0262:  ldloc.s    V_23
+    IL_0264:  ldloc.s    V_23
+    IL_0266:  ldloc.s    V_23
+    IL_0268:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_026d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0272:  ldloc.s    V_23
+    IL_0274:  newobj     instance void assembly/'Pipe #3 input at line 56@57'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0279:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_027e:  ldsfld     class assembly/'Pipe #3 input at line 56@58-1' assembly/'Pipe #3 input at line 56@58-1'::@_instance
+    IL_0283:  ldsfld     class assembly/'Pipe #3 input at line 56@58-2' assembly/'Pipe #3 input at line 56@58-2'::@_instance
+    IL_0288:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_028d:  ldloc.s    V_23
+    IL_028f:  newobj     instance void assembly/'Pipe #3 input at line 56@58-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0294:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0299:  ldsfld     class assembly/'Pipe #3 input at line 56@60-4' assembly/'Pipe #3 input at line 56@60-4'::@_instance
+    IL_029e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_02a3:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_02a8:  stloc.s    V_22
+    IL_02aa:  ldloc.s    V_22
+    IL_02ac:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_02b1:  stsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories2@55
+    IL_02b6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_02bb:  stloc.s    V_25
+    IL_02bd:  ldloc.s    V_25
+    IL_02bf:  ldloc.s    V_25
+    IL_02c1:  ldloc.s    V_25
+    IL_02c3:  ldloc.s    V_25
+    IL_02c5:  ldloc.s    V_25
+    IL_02c7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_02cc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_02d1:  ldloc.s    V_25
+    IL_02d3:  newobj     instance void assembly/'Pipe #4 input at line 65@66'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_02d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_02dd:  ldsfld     class assembly/'Pipe #4 input at line 65@67-1' assembly/'Pipe #4 input at line 65@67-1'::@_instance
+    IL_02e2:  ldsfld     class assembly/'Pipe #4 input at line 65@67-2' assembly/'Pipe #4 input at line 65@67-2'::@_instance
+    IL_02e7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_02ec:  ldloc.s    V_25
+    IL_02ee:  newobj     instance void assembly/'Pipe #4 input at line 65@67-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_02f3:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_02f8:  ldsfld     class assembly/'Pipe #4 input at line 65@70-4' assembly/'Pipe #4 input at line 65@70-4'::@_instance
+    IL_02fd:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0302:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0307:  stloc.s    V_24
+    IL_0309:  ldloc.s    V_24
+    IL_030b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0310:  stsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::categories3@64
+    IL_0315:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_031a:  ldnull
+    IL_031b:  ldc.i4.0
+    IL_031c:  ldc.i4.0
+    IL_031d:  newobj     instance void assembly/maxNum@74::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                            int32,
+                                                                            int32)
+    IL_0322:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0327:  ldsfld     class assembly/'maxNum@74-1' assembly/'maxNum@74-1'::@_instance
+    IL_032c:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MaxBy<int32,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0331:  stsfld     int32 assembly::maxNum@74
+    IL_0336:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_033b:  ldnull
+    IL_033c:  ldc.i4.0
+    IL_033d:  ldnull
+    IL_033e:  newobj     instance void assembly/longestLength@77::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                   int32,
+                                                                                   string)
+    IL_0343:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0348:  ldsfld     class assembly/'longestLength@77-1' assembly/'longestLength@77-1'::@_instance
+    IL_034d:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MaxBy<string,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0352:  stsfld     int32 assembly::longestLength@77
+    IL_0357:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_035c:  stloc.s    V_27
+    IL_035e:  ldloc.s    V_27
+    IL_0360:  ldloc.s    V_27
+    IL_0362:  ldloc.s    V_27
+    IL_0364:  ldloc.s    V_27
+    IL_0366:  ldloc.s    V_27
+    IL_0368:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_036d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0372:  ldloc.s    V_27
+    IL_0374:  newobj     instance void assembly/'Pipe #5 input at line 81@82'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0379:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_037e:  ldsfld     class assembly/'Pipe #5 input at line 81@83-1' assembly/'Pipe #5 input at line 81@83-1'::@_instance
+    IL_0383:  ldsfld     class assembly/'Pipe #5 input at line 81@83-2' assembly/'Pipe #5 input at line 81@83-2'::@_instance
+    IL_0388:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_038d:  ldloc.s    V_27
+    IL_038f:  newobj     instance void assembly/'Pipe #5 input at line 81@83-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0394:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0399:  ldsfld     class assembly/'Pipe #5 input at line 81@85-4' assembly/'Pipe #5 input at line 81@85-4'::@_instance
+    IL_039e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_03a3:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_03a8:  stloc.s    V_26
+    IL_03aa:  ldloc.s    V_26
+    IL_03ac:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_03b1:  stsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories4@80
+    IL_03b6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_03bb:  stloc.s    V_29
+    IL_03bd:  ldloc.s    V_29
+    IL_03bf:  ldloc.s    V_29
+    IL_03c1:  ldloc.s    V_29
+    IL_03c3:  ldloc.s    V_29
+    IL_03c5:  ldloc.s    V_29
+    IL_03c7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_03cc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_03d1:  ldloc.s    V_29
+    IL_03d3:  newobj     instance void assembly/'Pipe #6 input at line 90@91'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_03d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_03dd:  ldsfld     class assembly/'Pipe #6 input at line 90@92-1' assembly/'Pipe #6 input at line 90@92-1'::@_instance
+    IL_03e2:  ldsfld     class assembly/'Pipe #6 input at line 90@92-2' assembly/'Pipe #6 input at line 90@92-2'::@_instance
+    IL_03e7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_03ec:  ldloc.s    V_29
+    IL_03ee:  newobj     instance void assembly/'Pipe #6 input at line 90@92-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_03f3:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_03f8:  ldsfld     class assembly/'Pipe #6 input at line 90@95-4' assembly/'Pipe #6 input at line 90@95-4'::@_instance
+    IL_03fd:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0402:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0407:  stloc.s    V_28
+    IL_0409:  ldloc.s    V_28
+    IL_040b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0410:  stsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::categories5@89
+    IL_0415:  ldc.r8     5.0999999999999996
+    IL_041e:  ldc.r8     4.0999999999999996
+    IL_0427:  ldc.r8     1.1000000000000001
+    IL_0430:  ldc.r8     3.1000000000000001
+    IL_0439:  ldc.r8     9.0999999999999996
+    IL_0442:  ldc.r8     8.0999999999999996
+    IL_044b:  ldc.r8     6.0999999999999996
+    IL_0454:  ldc.r8     7.0999999999999996
+    IL_045d:  ldc.r8     2.1000000000000001
+    IL_0466:  ldc.r8     0.10000000000000001
+    IL_046f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::get_Empty()
+    IL_0474:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0479:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_047e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0483:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0488:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_048d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0492:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0497:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_049c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_04a1:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_04a6:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> assembly::numbers2@99
+    IL_04ab:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_04b0:  stloc.s    V_30
+    IL_04b2:  ldloc.s    V_30
+    IL_04b4:  stloc.s    V_31
+    IL_04b6:  ldnull
+    IL_04b7:  ldc.i4.0
+    IL_04b8:  ldc.r8     0.0
+    IL_04c1:  newobj     instance void assembly/averageNum@100::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<float64>,
+                                                                                 int32,
+                                                                                 float64)
+    IL_04c6:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<float64,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_04cb:  stloc.s    V_32
+    IL_04cd:  ldsfld     class assembly/'averageNum@100-1' assembly/'averageNum@100-1'::@_instance
+    IL_04d2:  stloc.s    V_33
+    IL_04d4:  ldloc.s    V_32
+    IL_04d6:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<float64,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_04db:  stloc.s    V_34
+    IL_04dd:  ldstr      "source"
+    IL_04e2:  stloc.s    V_35
+    IL_04e4:  ldloc.s    V_34
+    IL_04e6:  stloc.s    V_36
+    IL_04e8:  ldloc.s    V_36
+    IL_04ea:  box        class [runtime]System.Collections.Generic.IEnumerable`1<float64>
+    IL_04ef:  brtrue.s   IL_04fd
+
+    IL_04f1:  ldloc.s    V_35
+    IL_04f3:  stloc.s    V_37
+    IL_04f5:  ldloc.s    V_37
+    IL_04f7:  newobj     instance void [netstandard]System.ArgumentNullException::.ctor(string)
+    IL_04fc:  throw
+
+    IL_04fd:  nop
+    IL_04fe:  ldloc.s    V_34
+    IL_0500:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<float64>::GetEnumerator()
+    IL_0505:  stloc.s    V_38
+    .try
+    {
+      IL_0507:  ldc.r8     0.0
+      IL_0510:  stloc.s    V_40
+      IL_0512:  ldc.i4.0
+      IL_0513:  stloc.s    V_41
+      IL_0515:  br.s       IL_0530
+
+      IL_0517:  ldloc.s    V_40
+      IL_0519:  ldloc.s    V_33
+      IL_051b:  ldloc.s    V_38
+      IL_051d:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<float64>::get_Current()
+      IL_0522:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,float64>::Invoke(!0)
+      IL_0527:  add
+      IL_0528:  stloc.s    V_40
+      IL_052a:  ldloc.s    V_41
+      IL_052c:  ldc.i4.1
+      IL_052d:  add
+      IL_052e:  stloc.s    V_41
+      IL_0530:  ldloc.s    V_38
+      IL_0532:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+      IL_0537:  brtrue.s   IL_0517
+
+      IL_0539:  ldloc.s    V_41
+      IL_053b:  brtrue.s   IL_054c
+
+      IL_053d:  ldstr      "source"
+      IL_0542:  stloc.s    V_42
+      IL_0544:  ldloc.s    V_42
+      IL_0546:  newobj     instance void [netstandard]System.InvalidOperationException::.ctor(string)
+      IL_054b:  throw
+
+      IL_054c:  nop
+      IL_054d:  ldloc.s    V_40
+      IL_054f:  stloc.s    V_43
+      IL_0551:  ldloc.s    V_41
+      IL_0553:  stloc.s    V_44
+      IL_0555:  ldloc.s    V_43
+      IL_0557:  ldloc.s    V_44
+      IL_0559:  conv.r8
+      IL_055a:  div
+      IL_055b:  stloc.s    V_39
+      IL_055d:  leave.s    IL_0575
+
+    }  
+    finally
+    {
+      IL_055f:  ldloc.s    V_38
+      IL_0561:  isinst     [runtime]System.IDisposable
+      IL_0566:  stloc.s    V_45
+      IL_0568:  ldloc.s    V_45
+      IL_056a:  brfalse.s  IL_0574
+
+      IL_056c:  ldloc.s    V_45
+      IL_056e:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+      IL_0573:  endfinally
+      IL_0574:  endfinally
+    }  
+    IL_0575:  ldloc.s    V_39
+    IL_0577:  stsfld     float64 assembly::averageNum@100
+    IL_057c:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0581:  stloc.s    V_46
+    IL_0583:  ldloc.s    V_46
+    IL_0585:  stloc.s    V_47
+    IL_0587:  ldloc.s    V_46
+    IL_0589:  ldloc.s    V_46
+    IL_058b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+    IL_0590:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0595:  ldloc.s    V_46
+    IL_0597:  newobj     instance void assembly/averageLength@105::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_059c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<string,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,float64>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_05a1:  stloc.s    V_48
+    IL_05a3:  ldsfld     class assembly/'averageLength@107-1' assembly/'averageLength@107-1'::@_instance
+    IL_05a8:  stloc.s    V_49
+    IL_05aa:  ldloc.s    V_48
+    IL_05ac:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_05b1:  stloc.s    V_50
+    IL_05b3:  ldstr      "source"
+    IL_05b8:  stloc.s    V_51
+    IL_05ba:  ldloc.s    V_50
+    IL_05bc:  stloc.s    V_52
+    IL_05be:  ldloc.s    V_52
+    IL_05c0:  box        class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,float64>>
+    IL_05c5:  brtrue.s   IL_05d3
+
+    IL_05c7:  ldloc.s    V_51
+    IL_05c9:  stloc.s    V_53
+    IL_05cb:  ldloc.s    V_53
+    IL_05cd:  newobj     instance void [netstandard]System.ArgumentNullException::.ctor(string)
+    IL_05d2:  throw
+
+    IL_05d3:  nop
+    IL_05d4:  ldloc.s    V_50
+    IL_05d6:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,float64>>::GetEnumerator()
+    IL_05db:  stloc.s    V_54
+    .try
+    {
+      IL_05dd:  ldc.r8     0.0
+      IL_05e6:  stloc.s    V_56
+      IL_05e8:  ldc.i4.0
+      IL_05e9:  stloc.s    V_57
+      IL_05eb:  br.s       IL_0606
+
+      IL_05ed:  ldloc.s    V_56
+      IL_05ef:  ldloc.s    V_49
+      IL_05f1:  ldloc.s    V_54
+      IL_05f3:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<string,float64>>::get_Current()
+      IL_05f8:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,float64>,float64>::Invoke(!0)
+      IL_05fd:  add
+      IL_05fe:  stloc.s    V_56
+      IL_0600:  ldloc.s    V_57
+      IL_0602:  ldc.i4.1
+      IL_0603:  add
+      IL_0604:  stloc.s    V_57
+      IL_0606:  ldloc.s    V_54
+      IL_0608:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+      IL_060d:  brtrue.s   IL_05ed
+
+      IL_060f:  ldloc.s    V_57
+      IL_0611:  brtrue.s   IL_0622
+
+      IL_0613:  ldstr      "source"
+      IL_0618:  stloc.s    V_58
+      IL_061a:  ldloc.s    V_58
+      IL_061c:  newobj     instance void [netstandard]System.InvalidOperationException::.ctor(string)
+      IL_0621:  throw
+
+      IL_0622:  nop
+      IL_0623:  ldloc.s    V_56
+      IL_0625:  stloc.s    V_59
+      IL_0627:  ldloc.s    V_57
+      IL_0629:  stloc.s    V_60
+      IL_062b:  ldloc.s    V_59
+      IL_062d:  ldloc.s    V_60
+      IL_062f:  conv.r8
+      IL_0630:  div
+      IL_0631:  stloc.s    V_55
+      IL_0633:  leave.s    IL_064b
+
+    }  
+    finally
+    {
+      IL_0635:  ldloc.s    V_54
+      IL_0637:  isinst     [runtime]System.IDisposable
+      IL_063c:  stloc.s    V_61
+      IL_063e:  ldloc.s    V_61
+      IL_0640:  brfalse.s  IL_064a
+
+      IL_0642:  ldloc.s    V_61
+      IL_0644:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+      IL_0649:  endfinally
+      IL_064a:  endfinally
+    }  
+    IL_064b:  ldloc.s    V_55
+    IL_064d:  stsfld     float64 assembly::averageLength@103
+    IL_0652:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0657:  stloc.s    V_63
+    IL_0659:  ldloc.s    V_63
+    IL_065b:  ldloc.s    V_63
+    IL_065d:  ldloc.s    V_63
+    IL_065f:  ldloc.s    V_63
+    IL_0661:  ldloc.s    V_63
+    IL_0663:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_0668:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_066d:  ldloc.s    V_63
+    IL_066f:  newobj     instance void assembly/'Pipe #7 input at line 112@113'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0674:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0679:  ldsfld     class assembly/'Pipe #7 input at line 112@114-1' assembly/'Pipe #7 input at line 112@114-1'::@_instance
+    IL_067e:  ldsfld     class assembly/'Pipe #7 input at line 112@114-2' assembly/'Pipe #7 input at line 112@114-2'::@_instance
+    IL_0683:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_0688:  ldloc.s    V_63
+    IL_068a:  newobj     instance void assembly/'Pipe #7 input at line 112@114-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_068f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0694:  ldsfld     class assembly/'Pipe #7 input at line 112@116-4' assembly/'Pipe #7 input at line 112@116-4'::@_instance
+    IL_0699:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_069e:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_06a3:  stloc.s    V_62
+    IL_06a5:  ldloc.s    V_62
+    IL_06a7:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_06ac:  stsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories6@111
+    IL_06b1:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          factorsOf300()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_factorsOf300()
+  } 
+  .property int32 uniqueFactors()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_uniqueFactors()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property int32 numSum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_numSum()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property int32 totalChars()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_totalChars()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Tuple`2<string,int32>[]
+          categories()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,int32>[] assembly::get_categories()
+  } 
+  .property int32 minNum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_minNum()
+  } 
+  .property int32 shortestWord()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_shortestWord()
+  } 
+  .property class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[]
+          categories2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::get_categories2()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[]
+          categories3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::get_categories3()
+  } 
+  .property int32 maxNum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_maxNum()
+  } 
+  .property int32 longestLength()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_longestLength()
+  } 
+  .property class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[]
+          categories4()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::get_categories4()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[]
+          categories5()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::get_categories5()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>
+          numbers2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> assembly::get_numbers2()
+  } 
+  .property float64 averageNum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get float64 assembly::get_averageNum()
+  } 
+  .property float64 averageLength()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get float64 assembly::get_averageLength()
+  } 
+  .property class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[]
+          categories6()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::get_categories6()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOn.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOn.il.net472.release.bsl
new file mode 100644
index 00000000000..2d1d0cb1403
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOn.il.net472.release.bsl
@@ -0,0 +1,7081 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern System.Core
+{
+  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         
+  .ver 4:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 11@12'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_factorsOf300()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 11@12'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname numSum@21
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/numSum@21::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/numSum@21::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/numSum@21::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/numSum@21::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/numSum@21::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/numSum@21::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/numSum@21::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/numSum@21::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/numSum@21::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/numSum@21::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/numSum@21::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/numSum@21::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/numSum@21::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/numSum@21::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/numSum@21::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/numSum@21::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/numSum@21::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                              int32,
+                                                                              int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'numSum@22-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'numSum@22-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'numSum@22-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'numSum@22-1' assembly/'numSum@22-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname totalChars@30
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/totalChars@30::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/totalChars@30::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/totalChars@30::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/totalChars@30::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/totalChars@30::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/totalChars@30::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/totalChars@30::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/totalChars@30::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/totalChars@30::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/totalChars@30::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/totalChars@30::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/totalChars@30::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/totalChars@30::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/totalChars@30::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/totalChars@30::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/totalChars@30::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/totalChars@30::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                  int32,
+                                                                                  string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'totalChars@31-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'totalChars@31-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'totalChars@31-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'totalChars@31-1' assembly/'totalChars@31-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@39'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@39'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@39'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@40-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@40-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@40-1' assembly/'Pipe #2 input at line 38@40-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@40-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@40-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@40-2' assembly/'Pipe #2 input at line 38@40-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname sum@42
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/sum@42::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/sum@42::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/sum@42::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/sum@42::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/sum@42::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/sum@42::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/sum@42::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/sum@42::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/sum@42::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/sum@42::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/sum@42::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/sum@42::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/sum@42::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/sum@42::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/sum@42::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/sum@42::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/sum@42::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/sum@42::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/sum@42::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/sum@42::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                           int32,
+                                                                           class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'sum@43-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>
+  {
+    .field static assembly initonly class assembly/'sum@43-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'sum@43-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'sum@43-1' assembly/'sum@43-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@40-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               int32 V_1,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable> V_4,
+               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32> V_5,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_6,
+               class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> V_7,
+               int32 V_8,
+               int32 V_9,
+               class [runtime]System.IDisposable V_10)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  stloc.2
+      IL_0008:  ldloc.2
+      IL_0009:  stloc.3
+      IL_000a:  ldloc.0
+      IL_000b:  ldnull
+      IL_000c:  ldc.i4.0
+      IL_000d:  ldnull
+      IL_000e:  newobj     instance void assembly/sum@42::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                           int32,
+                                                                           class [Utils]Utils/Product)
+      IL_0013:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0018:  stloc.s    V_4
+      IL_001a:  ldsfld     class assembly/'sum@43-1' assembly/'sum@43-1'::@_instance
+      IL_001f:  stloc.s    V_5
+      IL_0021:  ldloc.s    V_4
+      IL_0023:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_0028:  stloc.s    V_6
+      IL_002a:  ldloc.s    V_6
+      IL_002c:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0031:  stloc.s    V_7
+      .try
+      {
+        IL_0033:  ldc.i4.0
+        IL_0034:  stloc.s    V_9
+        IL_0036:  br.s       IL_004b
+
+        IL_0038:  ldloc.s    V_9
+        IL_003a:  ldloc.s    V_5
+        IL_003c:  ldloc.s    V_7
+        IL_003e:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+        IL_0043:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>::Invoke(!0)
+        IL_0048:  add.ovf
+        IL_0049:  stloc.s    V_9
+        IL_004b:  ldloc.s    V_7
+        IL_004d:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+        IL_0052:  brtrue.s   IL_0038
+
+        IL_0054:  ldloc.s    V_9
+        IL_0056:  stloc.s    V_8
+        IL_0058:  leave.s    IL_0070
+
+      }  
+      finally
+      {
+        IL_005a:  ldloc.s    V_7
+        IL_005c:  isinst     [runtime]System.IDisposable
+        IL_0061:  stloc.s    V_10
+        IL_0063:  ldloc.s    V_10
+        IL_0065:  brfalse.s  IL_006f
+
+        IL_0067:  ldloc.s    V_10
+        IL_0069:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+        IL_006e:  endfinally
+        IL_006f:  endfinally
+      }  
+      IL_0070:  ldloc.s    V_8
+      IL_0072:  stloc.1
+      IL_0073:  ldarg.0
+      IL_0074:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@40-3'::builder@
+      IL_0079:  ldloc.0
+      IL_007a:  ldloc.1
+      IL_007b:  newobj     instance void class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>::.ctor(!0,
+                                                                                                                                                                    !1)
+      IL_0080:  tail.
+      IL_0082:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object>(!!0)
+      IL_0087:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@45-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,class [runtime]System.Tuple`2<string,int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@45-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,class [runtime]System.Tuple`2<string,int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,int32> Invoke(class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               int32 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,int32>::.ctor(!0,
+                                                                                             !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@45-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@45-4' assembly/'Pipe #2 input at line 38@45-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname minNum@49
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/minNum@49::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/minNum@49::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/minNum@49::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/minNum@49::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/minNum@49::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/minNum@49::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/minNum@49::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/minNum@49::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/minNum@49::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/minNum@49::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/minNum@49::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/minNum@49::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/minNum@49::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/minNum@49::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/minNum@49::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/minNum@49::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/minNum@49::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                              int32,
+                                                                              int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'minNum@49-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'minNum@49-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'minNum@49-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'minNum@49-1' assembly/'minNum@49-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname shortestWord@52
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/shortestWord@52::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/shortestWord@52::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/shortestWord@52::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/shortestWord@52::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/shortestWord@52::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/shortestWord@52::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/shortestWord@52::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/shortestWord@52::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/shortestWord@52::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/shortestWord@52::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/shortestWord@52::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/shortestWord@52::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/shortestWord@52::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/shortestWord@52::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/shortestWord@52::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/shortestWord@52::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/shortestWord@52::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                    int32,
+                                                                                    string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'shortestWord@52-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'shortestWord@52-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'shortestWord@52-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'shortestWord@52-1' assembly/'shortestWord@52-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@57'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 56@57'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 56@57'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@58-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 56@58-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 56@58-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 56@58-1' assembly/'Pipe #3 input at line 56@58-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@58-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 56@58-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 56@58-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 56@58-2' assembly/'Pipe #3 input at line 56@58-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname min@59
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/min@59::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/min@59::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/min@59::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/min@59::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/min@59::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/min@59::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/min@59::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/min@59::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/min@59::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/min@59::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/min@59::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/min@59::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/min@59::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/min@59::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/min@59::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/min@59::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/min@59::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/min@59::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/min@59::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/min@59::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                           int32,
+                                                                           class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'min@59-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'min@59-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'min@59-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'min@59-1' assembly/'min@59-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@58-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 56@58-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  ldloc.0
+      IL_0008:  ldnull
+      IL_0009:  ldc.i4.0
+      IL_000a:  ldnull
+      IL_000b:  newobj     instance void assembly/min@59::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                           int32,
+                                                                           class [Utils]Utils/Product)
+      IL_0010:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0015:  ldsfld     class assembly/'min@59-1' assembly/'min@59-1'::@_instance
+      IL_001a:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MinBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,valuetype [runtime]System.Decimal>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_001f:  stloc.1
+      IL_0020:  ldarg.0
+      IL_0021:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 56@58-3'::builder@
+      IL_0026:  ldloc.0
+      IL_0027:  ldloc.1
+      IL_0028:  newobj     instance void class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                                                                                 !1)
+      IL_002d:  tail.
+      IL_002f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(!!0)
+      IL_0034:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@60-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 56@60-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                          !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 56@60-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 56@60-4' assembly/'Pipe #3 input at line 56@60-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@66'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 65@66'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 65@66'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@67-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 65@67-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 65@67-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 65@67-1' assembly/'Pipe #4 input at line 65@67-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@67-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 65@67-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 65@67-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 65@67-2' assembly/'Pipe #4 input at line 65@67-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class abstract auto autochar serializable sealed nested assembly beforefieldinit specialname 'min@68-2'
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method assembly static valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname cheapestProducts@69
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/cheapestProducts@69::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/cheapestProducts@69::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/cheapestProducts@69::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/cheapestProducts@69::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/cheapestProducts@69::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/cheapestProducts@69::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/cheapestProducts@69::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/cheapestProducts@69::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/cheapestProducts@69::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/cheapestProducts@69::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                        class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                        int32,
+                                                                                        class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'cheapestProducts@69-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field public valuetype [runtime]System.Decimal min
+    .method assembly specialname rtspecialname instance void  .ctor(valuetype [runtime]System.Decimal min) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      valuetype [runtime]System.Decimal assembly/'cheapestProducts@69-1'::min
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0006:  ldarg.0
+      IL_0007:  ldfld      valuetype [runtime]System.Decimal assembly/'cheapestProducts@69-1'::min
+      IL_000c:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                         valuetype [netstandard]System.Decimal)
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@67-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 65@67-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_2,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  ldnull
+      IL_0004:  ldftn      valuetype [runtime]System.Decimal assembly/'min@68-2'::Invoke(class [Utils]Utils/Product)
+      IL_000a:  newobj     instance void class [runtime]System.Func`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor(object,
+                                                                                                                                             native int)
+      IL_000f:  call       valuetype [runtime]System.Decimal [System.Core]System.Linq.Enumerable::Min<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                                                   class [runtime]System.Func`2<!!0,valuetype [runtime]System.Decimal>)
+      IL_0014:  stloc.1
+      IL_0015:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_001a:  stloc.3
+      IL_001b:  ldloc.3
+      IL_001c:  ldloc.0
+      IL_001d:  ldnull
+      IL_001e:  ldc.i4.0
+      IL_001f:  ldnull
+      IL_0020:  newobj     instance void assembly/cheapestProducts@69::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                        class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                        int32,
+                                                                                        class [Utils]Utils/Product)
+      IL_0025:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_002a:  ldloc.1
+      IL_002b:  newobj     instance void assembly/'cheapestProducts@69-1'::.ctor(valuetype [runtime]System.Decimal)
+      IL_0030:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_003a:  stloc.2
+      IL_003b:  ldarg.0
+      IL_003c:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 65@67-3'::builder@
+      IL_0041:  ldloc.0
+      IL_0042:  ldloc.1
+      IL_0043:  ldloc.2
+      IL_0044:  newobj     instance void class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                                                                                                                      !1,
+                                                                                                                                                                                                                                                                                      !2)
+      IL_0049:  tail.
+      IL_004b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(!!0)
+      IL_0050:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@70-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 65@70-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> Invoke(class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldarg.1
+      IL_000f:  call       instance !2 class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item3()
+      IL_0014:  stloc.2
+      IL_0015:  ldloc.0
+      IL_0016:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_001b:  ldloc.2
+      IL_001c:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                            !1)
+      IL_0021:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 65@70-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 65@70-4' assembly/'Pipe #4 input at line 65@70-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname maxNum@74
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/maxNum@74::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/maxNum@74::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxNum@74::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/maxNum@74::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/maxNum@74::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/maxNum@74::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/maxNum@74::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/maxNum@74::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/maxNum@74::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxNum@74::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/maxNum@74::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/maxNum@74::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/maxNum@74::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/maxNum@74::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxNum@74::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxNum@74::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/maxNum@74::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                              int32,
+                                                                              int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'maxNum@74-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'maxNum@74-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'maxNum@74-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'maxNum@74-1' assembly/'maxNum@74-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname longestLength@77
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/longestLength@77::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/longestLength@77::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/longestLength@77::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/longestLength@77::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/longestLength@77::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/longestLength@77::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/longestLength@77::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/longestLength@77::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/longestLength@77::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/longestLength@77::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/longestLength@77::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/longestLength@77::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/longestLength@77::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/longestLength@77::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/longestLength@77::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/longestLength@77::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/longestLength@77::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                     int32,
+                                                                                     string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'longestLength@77-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'longestLength@77-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'longestLength@77-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'longestLength@77-1' assembly/'longestLength@77-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@82'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #5 input at line 81@82'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #5 input at line 81@82'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@83-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 81@83-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 81@83-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 81@83-1' assembly/'Pipe #5 input at line 81@83-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@83-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 81@83-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 81@83-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 81@83-2' assembly/'Pipe #5 input at line 81@83-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname mostExpensivePrice@84
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensivePrice@84::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensivePrice@84::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/mostExpensivePrice@84::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/mostExpensivePrice@84::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/mostExpensivePrice@84::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensivePrice@84::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/mostExpensivePrice@84::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                          class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                          int32,
+                                                                                          class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'mostExpensivePrice@84-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'mostExpensivePrice@84-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'mostExpensivePrice@84-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'mostExpensivePrice@84-1' assembly/'mostExpensivePrice@84-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@83-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #5 input at line 81@83-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  ldloc.0
+      IL_0008:  ldnull
+      IL_0009:  ldc.i4.0
+      IL_000a:  ldnull
+      IL_000b:  newobj     instance void assembly/mostExpensivePrice@84::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                          class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                          int32,
+                                                                                          class [Utils]Utils/Product)
+      IL_0010:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0015:  ldsfld     class assembly/'mostExpensivePrice@84-1' assembly/'mostExpensivePrice@84-1'::@_instance
+      IL_001a:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MaxBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,valuetype [runtime]System.Decimal>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_001f:  stloc.1
+      IL_0020:  ldarg.0
+      IL_0021:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #5 input at line 81@83-3'::builder@
+      IL_0026:  ldloc.0
+      IL_0027:  ldloc.1
+      IL_0028:  newobj     instance void class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                                                                                 !1)
+      IL_002d:  tail.
+      IL_002f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(!!0)
+      IL_0034:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@85-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 81@85-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                          !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 81@85-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 81@85-4' assembly/'Pipe #5 input at line 81@85-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@91'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 90@91'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 90@91'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@92-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 90@92-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 90@92-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 90@92-1' assembly/'Pipe #6 input at line 90@92-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@92-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 90@92-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 90@92-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 90@92-2' assembly/'Pipe #6 input at line 90@92-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname maxPrice@93
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/maxPrice@93::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/maxPrice@93::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxPrice@93::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/maxPrice@93::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/maxPrice@93::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/maxPrice@93::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/maxPrice@93::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/maxPrice@93::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxPrice@93::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/maxPrice@93::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/maxPrice@93::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/maxPrice@93::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxPrice@93::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/maxPrice@93::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/maxPrice@93::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                int32,
+                                                                                class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'maxPrice@93-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'maxPrice@93-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'maxPrice@93-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'maxPrice@93-1' assembly/'maxPrice@93-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname mostExpensiveProducts@94
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/mostExpensiveProducts@94::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/mostExpensiveProducts@94::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                             class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                             int32,
+                                                                                             class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'mostExpensiveProducts@94-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field public valuetype [runtime]System.Decimal maxPrice
+    .method assembly specialname rtspecialname instance void  .ctor(valuetype [runtime]System.Decimal maxPrice) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      valuetype [runtime]System.Decimal assembly/'mostExpensiveProducts@94-1'::maxPrice
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0006:  ldarg.0
+      IL_0007:  ldfld      valuetype [runtime]System.Decimal assembly/'mostExpensiveProducts@94-1'::maxPrice
+      IL_000c:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                         valuetype [netstandard]System.Decimal)
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@92-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 90@92-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_2,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  ldloc.0
+      IL_0008:  ldnull
+      IL_0009:  ldc.i4.0
+      IL_000a:  ldnull
+      IL_000b:  newobj     instance void assembly/maxPrice@93::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                int32,
+                                                                                class [Utils]Utils/Product)
+      IL_0010:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0015:  ldsfld     class assembly/'maxPrice@93-1' assembly/'maxPrice@93-1'::@_instance
+      IL_001a:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MaxBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,valuetype [runtime]System.Decimal>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_001f:  stloc.1
+      IL_0020:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0025:  stloc.3
+      IL_0026:  ldloc.3
+      IL_0027:  ldloc.0
+      IL_0028:  ldnull
+      IL_0029:  ldc.i4.0
+      IL_002a:  ldnull
+      IL_002b:  newobj     instance void assembly/mostExpensiveProducts@94::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                             class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                             int32,
+                                                                                             class [Utils]Utils/Product)
+      IL_0030:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0035:  ldloc.1
+      IL_0036:  newobj     instance void assembly/'mostExpensiveProducts@94-1'::.ctor(valuetype [runtime]System.Decimal)
+      IL_003b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+      IL_0040:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_0045:  stloc.2
+      IL_0046:  ldarg.0
+      IL_0047:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 90@92-3'::builder@
+      IL_004c:  ldloc.0
+      IL_004d:  ldloc.1
+      IL_004e:  ldloc.2
+      IL_004f:  newobj     instance void class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                                                                                                                      !1,
+                                                                                                                                                                                                                                                                                      !2)
+      IL_0054:  tail.
+      IL_0056:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(!!0)
+      IL_005b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@95-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 90@95-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> Invoke(class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldarg.1
+      IL_000f:  call       instance !2 class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item3()
+      IL_0014:  stloc.2
+      IL_0015:  ldloc.0
+      IL_0016:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_001b:  ldloc.2
+      IL_001c:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                            !1)
+      IL_0021:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 90@95-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 90@95-4' assembly/'Pipe #6 input at line 90@95-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname averageNum@100
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<float64>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<float64> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public float64 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<float64> 'enum',
+                                 int32 pc,
+                                 float64 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/averageNum@100::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      float64 assembly/averageNum@100::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<float64>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<float64>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (float64 V_0,
+               float64 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averageNum@100::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> assembly::get_numbers2()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<float64>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/averageNum@100::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<float64>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/averageNum@100::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      float64 assembly/averageNum@100::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/averageNum@100::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<float64>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/averageNum@100::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.r8     0.0
+      IL_0095:  stfld      float64 assembly/averageNum@100::current
+      IL_009a:  ldc.i4.0
+      IL_009b:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averageNum@100::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_007e
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/averageNum@100::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/averageNum@100::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<float64>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/averageNum@100::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.r8     0.0
+        IL_0067:  stfld      float64 assembly/averageNum@100::current
+        IL_006c:  leave.s    IL_0078
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_006e:  castclass  [runtime]System.Exception
+        IL_0073:  stloc.1
+        IL_0074:  ldloc.1
+        IL_0075:  stloc.0
+        IL_0076:  leave.s    IL_0078
+
+      }  
+      IL_0078:  nop
+      IL_0079:  br         IL_0000
+
+      IL_007e:  ldloc.0
+      IL_007f:  brfalse.s  IL_0083
+
+      IL_0081:  ldloc.0
+      IL_0082:  throw
+
+      IL_0083:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averageNum@100::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance float64 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      float64 assembly/averageNum@100::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<float64> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.r8     0.0
+      IL_000b:  newobj     instance void assembly/averageNum@100::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<float64>,
+                                                                                   int32,
+                                                                                   float64)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'averageNum@100-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,float64>
+  {
+    .field static assembly initonly class assembly/'averageNum@100-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,float64>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance float64 Invoke(float64 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'averageNum@100-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'averageNum@100-1' assembly/'averageNum@100-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit averageLength@105
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/averageLength@105::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,object> Invoke(string _arg1) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (string V_0,
+               float64 V_1,
+               int32 V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0008:  stloc.2
+      IL_0009:  ldloc.2
+      IL_000a:  conv.r8
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/averageLength@105::builder@
+      IL_0012:  ldloc.0
+      IL_0013:  ldloc.1
+      IL_0014:  newobj     instance void class [runtime]System.Tuple`2<string,float64>::.ctor(!0,
+                                                                                               !1)
+      IL_0019:  tail.
+      IL_001b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<string,float64>,object>(!!0)
+      IL_0020:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'averageLength@107-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,float64>,float64>
+  {
+    .field static assembly initonly class assembly/'averageLength@107-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,float64>,float64>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance float64 Invoke(class [runtime]System.Tuple`2<string,float64> tupledArg) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (string V_0,
+               float64 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<string,float64>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<string,float64>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'averageLength@107-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'averageLength@107-1' assembly/'averageLength@107-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@113'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 112@113'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 112@113'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@114-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 112@114-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 112@114-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 112@114-1' assembly/'Pipe #7 input at line 112@114-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@114-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 112@114-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 112@114-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 112@114-2' assembly/'Pipe #7 input at line 112@114-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname averagePrice@115
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/averagePrice@115::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/averagePrice@115::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averagePrice@115::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/averagePrice@115::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/averagePrice@115::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/averagePrice@115::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/averagePrice@115::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/averagePrice@115::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averagePrice@115::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/averagePrice@115::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/averagePrice@115::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/averagePrice@115::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averagePrice@115::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/averagePrice@115::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/averagePrice@115::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                     class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                     int32,
+                                                                                     class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'averagePrice@115-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'averagePrice@115-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'averagePrice@115-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'averagePrice@115-1' assembly/'averagePrice@115-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@114-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 112@114-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable> V_4,
+               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal> V_5,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_6,
+               class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> V_7,
+               valuetype [runtime]System.Decimal V_8,
+               valuetype [runtime]System.Decimal V_9,
+               int32 V_10,
+               valuetype [runtime]System.Decimal V_11,
+               int32 V_12,
+               class [runtime]System.IDisposable V_13)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  stloc.2
+      IL_0008:  ldloc.2
+      IL_0009:  stloc.3
+      IL_000a:  ldloc.0
+      IL_000b:  ldnull
+      IL_000c:  ldc.i4.0
+      IL_000d:  ldnull
+      IL_000e:  newobj     instance void assembly/averagePrice@115::.ctor(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                     class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                     int32,
+                                                                                     class [Utils]Utils/Product)
+      IL_0013:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0018:  stloc.s    V_4
+      IL_001a:  ldsfld     class assembly/'averagePrice@115-1' assembly/'averagePrice@115-1'::@_instance
+      IL_001f:  stloc.s    V_5
+      IL_0021:  ldloc.s    V_4
+      IL_0023:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_0028:  stloc.s    V_6
+      IL_002a:  ldloc.s    V_6
+      IL_002c:  box        class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>
+      IL_0031:  brtrue.s   IL_003e
+
+      IL_0033:  ldstr      "source"
+      IL_0038:  newobj     instance void [netstandard]System.ArgumentNullException::.ctor(string)
+      IL_003d:  throw
+
+      IL_003e:  nop
+      IL_003f:  ldloc.s    V_6
+      IL_0041:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0046:  stloc.s    V_7
+      .try
+      {
+        IL_0048:  ldc.i4.0
+        IL_0049:  ldc.i4.0
+        IL_004a:  ldc.i4.0
+        IL_004b:  ldc.i4.0
+        IL_004c:  ldc.i4.0
+        IL_004d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                              int32,
+                                                                              int32,
+                                                                              bool,
+                                                                              uint8)
+        IL_0052:  stloc.s    V_9
+        IL_0054:  ldc.i4.0
+        IL_0055:  stloc.s    V_10
+        IL_0057:  br.s       IL_0076
+
+        IL_0059:  ldloc.s    V_9
+        IL_005b:  ldloc.s    V_5
+        IL_005d:  ldloc.s    V_7
+        IL_005f:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+        IL_0064:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::Invoke(!0)
+        IL_0069:  call       valuetype [netstandard]System.Decimal [netstandard]System.Decimal::op_Addition(valuetype [netstandard]System.Decimal,
+                                                                                                            valuetype [netstandard]System.Decimal)
+        IL_006e:  stloc.s    V_9
+        IL_0070:  ldloc.s    V_10
+        IL_0072:  ldc.i4.1
+        IL_0073:  add
+        IL_0074:  stloc.s    V_10
+        IL_0076:  ldloc.s    V_7
+        IL_0078:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+        IL_007d:  brtrue.s   IL_0059
+
+        IL_007f:  ldloc.s    V_10
+        IL_0081:  brtrue.s   IL_008e
+
+        IL_0083:  ldstr      "source"
+        IL_0088:  newobj     instance void [netstandard]System.InvalidOperationException::.ctor(string)
+        IL_008d:  throw
+
+        IL_008e:  nop
+        IL_008f:  ldloc.s    V_9
+        IL_0091:  stloc.s    V_11
+        IL_0093:  ldloc.s    V_10
+        IL_0095:  stloc.s    V_12
+        IL_0097:  ldloc.s    V_11
+        IL_0099:  ldloc.s    V_12
+        IL_009b:  call       valuetype [netstandard]System.Decimal [netstandard]System.Convert::ToDecimal(int32)
+        IL_00a0:  call       valuetype [netstandard]System.Decimal [netstandard]System.Decimal::Divide(valuetype [netstandard]System.Decimal,
+                                                                                                       valuetype [netstandard]System.Decimal)
+        IL_00a5:  stloc.s    V_8
+        IL_00a7:  leave.s    IL_00bf
+
+      }  
+      finally
+      {
+        IL_00a9:  ldloc.s    V_7
+        IL_00ab:  isinst     [runtime]System.IDisposable
+        IL_00b0:  stloc.s    V_13
+        IL_00b2:  ldloc.s    V_13
+        IL_00b4:  brfalse.s  IL_00be
+
+        IL_00b6:  ldloc.s    V_13
+        IL_00b8:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+        IL_00bd:  endfinally
+        IL_00be:  endfinally
+      }  
+      IL_00bf:  ldloc.s    V_8
+      IL_00c1:  stloc.1
+      IL_00c2:  ldarg.0
+      IL_00c3:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 112@114-3'::builder@
+      IL_00c8:  ldloc.0
+      IL_00c9:  ldloc.1
+      IL_00ca:  newobj     instance void class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                                                                                 !1)
+      IL_00cf:  tail.
+      IL_00d1:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(!!0)
+      IL_00d6:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@116-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 112@116-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                          !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 112@116-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 112@116-4' assembly/'Pipe #7 input at line 112@116-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> factorsOf300@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 uniqueFactors@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 numSum@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@26
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 totalChars@28
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@35
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,int32>[] categories@37
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 minNum@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 shortestWord@52
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] categories2@55
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] categories3@64
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 maxNum@74
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 longestLength@77
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] categories4@80
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] categories5@89
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> numbers2@99
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly float64 averageNum@100
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly float64 averageLength@103
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] categories6@111
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_factorsOf300() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::factorsOf300@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_uniqueFactors() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::uniqueFactors@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@17
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_numSum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::numSum@19
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@26
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_totalChars() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::totalChars@28
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@35
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,int32>[] get_categories() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,int32>[] assembly::categories@37
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_minNum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::minNum@49
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_shortestWord() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::shortestWord@52
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] get_categories2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories2@55
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] get_categories3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::categories3@64
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_maxNum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::maxNum@74
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_longestLength() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::longestLength@77
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] get_categories4() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories4@80
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] get_categories5() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::categories5@89
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> get_numbers2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> assembly::numbers2@99
+    IL_0005:  ret
+  } 
+
+  .method public specialname static float64 get_averageNum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     float64 assembly::averageNum@100
+    IL_0005:  ret
+  } 
+
+  .method public specialname static float64 get_averageLength() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     float64 assembly::averageLength@103
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] get_categories6() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories6@111
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32> V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_6,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_7,
+             int32 V_8,
+             int32 V_9,
+             class [runtime]System.IDisposable V_10,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_11,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_12,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable> V_13,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32> V_14,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_15,
+             class [runtime]System.Collections.Generic.IEnumerator`1<string> V_16,
+             int32 V_17,
+             int32 V_18,
+             class [runtime]System.IDisposable V_19,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> V_20,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_21,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>> V_22,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_23,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>> V_24,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_25,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>> V_26,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_27,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>> V_28,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_29,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_30,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_31,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<float64,class [runtime]System.Collections.IEnumerable> V_32,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,float64> V_33,
+             class [runtime]System.Collections.Generic.IEnumerable`1<float64> V_34,
+             class [runtime]System.Collections.Generic.IEnumerator`1<float64> V_35,
+             float64 V_36,
+             float64 V_37,
+             int32 V_38,
+             float64 V_39,
+             int32 V_40,
+             class [runtime]System.IDisposable V_41,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_42,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_43,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,class [runtime]System.Collections.IEnumerable> V_44,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,float64>,float64> V_45,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,float64>> V_46,
+             class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<string,float64>> V_47,
+             float64 V_48,
+             float64 V_49,
+             int32 V_50,
+             float64 V_51,
+             int32 V_52,
+             class [runtime]System.IDisposable V_53,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>> V_54,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_55)
+    IL_0000:  ldc.i4.2
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  ldc.i4.5
+    IL_0004:  ldc.i4.5
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::factorsOf300@8
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_002d:  stloc.1
+    IL_002e:  ldloc.1
+    IL_002f:  ldnull
+    IL_0030:  ldc.i4.0
+    IL_0031:  ldc.i4.0
+    IL_0032:  newobj     instance void assembly/'Pipe #1 input at line 11@12'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                int32,
+                                                                                                int32)
+    IL_0037:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_003c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Distinct<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_0041:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0046:  stloc.0
+    IL_0047:  ldloc.0
+    IL_0048:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_004d:  stsfld     int32 assembly::uniqueFactors@10
+    IL_0052:  ldc.i4.5
+    IL_0053:  ldc.i4.4
+    IL_0054:  ldc.i4.1
+    IL_0055:  ldc.i4.3
+    IL_0056:  ldc.i4.s   9
+    IL_0058:  ldc.i4.8
+    IL_0059:  ldc.i4.6
+    IL_005a:  ldc.i4.7
+    IL_005b:  ldc.i4.2
+    IL_005c:  ldc.i4.0
+    IL_005d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0062:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0067:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_006c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0071:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0076:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_007b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0080:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0085:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_008a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_008f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0094:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@17
+    IL_0099:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_009e:  stloc.2
+    IL_009f:  ldloc.2
+    IL_00a0:  stloc.3
+    IL_00a1:  ldnull
+    IL_00a2:  ldc.i4.0
+    IL_00a3:  ldc.i4.0
+    IL_00a4:  newobj     instance void assembly/numSum@21::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                            int32,
+                                                                            int32)
+    IL_00a9:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00ae:  stloc.s    V_4
+    IL_00b0:  ldsfld     class assembly/'numSum@22-1' assembly/'numSum@22-1'::@_instance
+    IL_00b5:  stloc.s    V_5
+    IL_00b7:  ldloc.s    V_4
+    IL_00b9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00be:  stloc.s    V_6
+    IL_00c0:  ldloc.s    V_6
+    IL_00c2:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_00c7:  stloc.s    V_7
+    .try
+    {
+      IL_00c9:  ldc.i4.0
+      IL_00ca:  stloc.s    V_9
+      IL_00cc:  br.s       IL_00e1
+
+      IL_00ce:  ldloc.s    V_9
+      IL_00d0:  ldloc.s    V_5
+      IL_00d2:  ldloc.s    V_7
+      IL_00d4:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_00d9:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::Invoke(!0)
+      IL_00de:  add.ovf
+      IL_00df:  stloc.s    V_9
+      IL_00e1:  ldloc.s    V_7
+      IL_00e3:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+      IL_00e8:  brtrue.s   IL_00ce
+
+      IL_00ea:  ldloc.s    V_9
+      IL_00ec:  stloc.s    V_8
+      IL_00ee:  leave.s    IL_0106
+
+    }  
+    finally
+    {
+      IL_00f0:  ldloc.s    V_7
+      IL_00f2:  isinst     [runtime]System.IDisposable
+      IL_00f7:  stloc.s    V_10
+      IL_00f9:  ldloc.s    V_10
+      IL_00fb:  brfalse.s  IL_0105
+
+      IL_00fd:  ldloc.s    V_10
+      IL_00ff:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+      IL_0104:  endfinally
+      IL_0105:  endfinally
+    }  
+    IL_0106:  ldloc.s    V_8
+    IL_0108:  stsfld     int32 assembly::numSum@19
+    IL_010d:  ldstr      "cherry"
+    IL_0112:  ldstr      "apple"
+    IL_0117:  ldstr      "blueberry"
+    IL_011c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0121:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0126:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_012b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0130:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@26
+    IL_0135:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_013a:  stloc.s    V_11
+    IL_013c:  ldloc.s    V_11
+    IL_013e:  stloc.s    V_12
+    IL_0140:  ldnull
+    IL_0141:  ldc.i4.0
+    IL_0142:  ldnull
+    IL_0143:  newobj     instance void assembly/totalChars@30::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                int32,
+                                                                                string)
+    IL_0148:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_014d:  stloc.s    V_13
+    IL_014f:  ldsfld     class assembly/'totalChars@31-1' assembly/'totalChars@31-1'::@_instance
+    IL_0154:  stloc.s    V_14
+    IL_0156:  ldloc.s    V_13
+    IL_0158:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_015d:  stloc.s    V_15
+    IL_015f:  ldloc.s    V_15
+    IL_0161:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+    IL_0166:  stloc.s    V_16
+    .try
+    {
+      IL_0168:  ldc.i4.0
+      IL_0169:  stloc.s    V_18
+      IL_016b:  br.s       IL_0180
+
+      IL_016d:  ldloc.s    V_18
+      IL_016f:  ldloc.s    V_14
+      IL_0171:  ldloc.s    V_16
+      IL_0173:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_0178:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::Invoke(!0)
+      IL_017d:  add.ovf
+      IL_017e:  stloc.s    V_18
+      IL_0180:  ldloc.s    V_16
+      IL_0182:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+      IL_0187:  brtrue.s   IL_016d
+
+      IL_0189:  ldloc.s    V_18
+      IL_018b:  stloc.s    V_17
+      IL_018d:  leave.s    IL_01a5
+
+    }  
+    finally
+    {
+      IL_018f:  ldloc.s    V_16
+      IL_0191:  isinst     [runtime]System.IDisposable
+      IL_0196:  stloc.s    V_19
+      IL_0198:  ldloc.s    V_19
+      IL_019a:  brfalse.s  IL_01a4
+
+      IL_019c:  ldloc.s    V_19
+      IL_019e:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+      IL_01a3:  endfinally
+      IL_01a4:  endfinally
+    }  
+    IL_01a5:  ldloc.s    V_17
+    IL_01a7:  stsfld     int32 assembly::totalChars@28
+    IL_01ac:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_01b1:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@35
+    IL_01b6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_01bb:  stloc.s    V_21
+    IL_01bd:  ldloc.s    V_21
+    IL_01bf:  ldloc.s    V_21
+    IL_01c1:  ldloc.s    V_21
+    IL_01c3:  ldloc.s    V_21
+    IL_01c5:  ldloc.s    V_21
+    IL_01c7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_01cc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01d1:  ldloc.s    V_21
+    IL_01d3:  newobj     instance void assembly/'Pipe #2 input at line 38@39'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01dd:  ldsfld     class assembly/'Pipe #2 input at line 38@40-1' assembly/'Pipe #2 input at line 38@40-1'::@_instance
+    IL_01e2:  ldsfld     class assembly/'Pipe #2 input at line 38@40-2' assembly/'Pipe #2 input at line 38@40-2'::@_instance
+    IL_01e7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_01ec:  ldloc.s    V_21
+    IL_01ee:  newobj     instance void assembly/'Pipe #2 input at line 38@40-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01f3:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01f8:  ldsfld     class assembly/'Pipe #2 input at line 38@45-4' assembly/'Pipe #2 input at line 38@45-4'::@_instance
+    IL_01fd:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,int32>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0202:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,int32>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0207:  stloc.s    V_20
+    IL_0209:  ldloc.s    V_20
+    IL_020b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,int32>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0210:  stsfld     class [runtime]System.Tuple`2<string,int32>[] assembly::categories@37
+    IL_0215:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_021a:  ldnull
+    IL_021b:  ldc.i4.0
+    IL_021c:  ldc.i4.0
+    IL_021d:  newobj     instance void assembly/minNum@49::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                            int32,
+                                                                            int32)
+    IL_0222:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0227:  ldsfld     class assembly/'minNum@49-1' assembly/'minNum@49-1'::@_instance
+    IL_022c:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MinBy<int32,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0231:  stsfld     int32 assembly::minNum@49
+    IL_0236:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_023b:  ldnull
+    IL_023c:  ldc.i4.0
+    IL_023d:  ldnull
+    IL_023e:  newobj     instance void assembly/shortestWord@52::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                  int32,
+                                                                                  string)
+    IL_0243:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0248:  ldsfld     class assembly/'shortestWord@52-1' assembly/'shortestWord@52-1'::@_instance
+    IL_024d:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MinBy<string,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0252:  stsfld     int32 assembly::shortestWord@52
+    IL_0257:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_025c:  stloc.s    V_23
+    IL_025e:  ldloc.s    V_23
+    IL_0260:  ldloc.s    V_23
+    IL_0262:  ldloc.s    V_23
+    IL_0264:  ldloc.s    V_23
+    IL_0266:  ldloc.s    V_23
+    IL_0268:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_026d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0272:  ldloc.s    V_23
+    IL_0274:  newobj     instance void assembly/'Pipe #3 input at line 56@57'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0279:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_027e:  ldsfld     class assembly/'Pipe #3 input at line 56@58-1' assembly/'Pipe #3 input at line 56@58-1'::@_instance
+    IL_0283:  ldsfld     class assembly/'Pipe #3 input at line 56@58-2' assembly/'Pipe #3 input at line 56@58-2'::@_instance
+    IL_0288:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_028d:  ldloc.s    V_23
+    IL_028f:  newobj     instance void assembly/'Pipe #3 input at line 56@58-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0294:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0299:  ldsfld     class assembly/'Pipe #3 input at line 56@60-4' assembly/'Pipe #3 input at line 56@60-4'::@_instance
+    IL_029e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_02a3:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_02a8:  stloc.s    V_22
+    IL_02aa:  ldloc.s    V_22
+    IL_02ac:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_02b1:  stsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories2@55
+    IL_02b6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_02bb:  stloc.s    V_25
+    IL_02bd:  ldloc.s    V_25
+    IL_02bf:  ldloc.s    V_25
+    IL_02c1:  ldloc.s    V_25
+    IL_02c3:  ldloc.s    V_25
+    IL_02c5:  ldloc.s    V_25
+    IL_02c7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_02cc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_02d1:  ldloc.s    V_25
+    IL_02d3:  newobj     instance void assembly/'Pipe #4 input at line 65@66'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_02d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_02dd:  ldsfld     class assembly/'Pipe #4 input at line 65@67-1' assembly/'Pipe #4 input at line 65@67-1'::@_instance
+    IL_02e2:  ldsfld     class assembly/'Pipe #4 input at line 65@67-2' assembly/'Pipe #4 input at line 65@67-2'::@_instance
+    IL_02e7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_02ec:  ldloc.s    V_25
+    IL_02ee:  newobj     instance void assembly/'Pipe #4 input at line 65@67-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_02f3:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_02f8:  ldsfld     class assembly/'Pipe #4 input at line 65@70-4' assembly/'Pipe #4 input at line 65@70-4'::@_instance
+    IL_02fd:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0302:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0307:  stloc.s    V_24
+    IL_0309:  ldloc.s    V_24
+    IL_030b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0310:  stsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::categories3@64
+    IL_0315:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_031a:  ldnull
+    IL_031b:  ldc.i4.0
+    IL_031c:  ldc.i4.0
+    IL_031d:  newobj     instance void assembly/maxNum@74::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                            int32,
+                                                                            int32)
+    IL_0322:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0327:  ldsfld     class assembly/'maxNum@74-1' assembly/'maxNum@74-1'::@_instance
+    IL_032c:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MaxBy<int32,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0331:  stsfld     int32 assembly::maxNum@74
+    IL_0336:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_033b:  ldnull
+    IL_033c:  ldc.i4.0
+    IL_033d:  ldnull
+    IL_033e:  newobj     instance void assembly/longestLength@77::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                   int32,
+                                                                                   string)
+    IL_0343:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0348:  ldsfld     class assembly/'longestLength@77-1' assembly/'longestLength@77-1'::@_instance
+    IL_034d:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MaxBy<string,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0352:  stsfld     int32 assembly::longestLength@77
+    IL_0357:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_035c:  stloc.s    V_27
+    IL_035e:  ldloc.s    V_27
+    IL_0360:  ldloc.s    V_27
+    IL_0362:  ldloc.s    V_27
+    IL_0364:  ldloc.s    V_27
+    IL_0366:  ldloc.s    V_27
+    IL_0368:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_036d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0372:  ldloc.s    V_27
+    IL_0374:  newobj     instance void assembly/'Pipe #5 input at line 81@82'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0379:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_037e:  ldsfld     class assembly/'Pipe #5 input at line 81@83-1' assembly/'Pipe #5 input at line 81@83-1'::@_instance
+    IL_0383:  ldsfld     class assembly/'Pipe #5 input at line 81@83-2' assembly/'Pipe #5 input at line 81@83-2'::@_instance
+    IL_0388:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_038d:  ldloc.s    V_27
+    IL_038f:  newobj     instance void assembly/'Pipe #5 input at line 81@83-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0394:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0399:  ldsfld     class assembly/'Pipe #5 input at line 81@85-4' assembly/'Pipe #5 input at line 81@85-4'::@_instance
+    IL_039e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_03a3:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_03a8:  stloc.s    V_26
+    IL_03aa:  ldloc.s    V_26
+    IL_03ac:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_03b1:  stsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories4@80
+    IL_03b6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_03bb:  stloc.s    V_29
+    IL_03bd:  ldloc.s    V_29
+    IL_03bf:  ldloc.s    V_29
+    IL_03c1:  ldloc.s    V_29
+    IL_03c3:  ldloc.s    V_29
+    IL_03c5:  ldloc.s    V_29
+    IL_03c7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_03cc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_03d1:  ldloc.s    V_29
+    IL_03d3:  newobj     instance void assembly/'Pipe #6 input at line 90@91'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_03d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_03dd:  ldsfld     class assembly/'Pipe #6 input at line 90@92-1' assembly/'Pipe #6 input at line 90@92-1'::@_instance
+    IL_03e2:  ldsfld     class assembly/'Pipe #6 input at line 90@92-2' assembly/'Pipe #6 input at line 90@92-2'::@_instance
+    IL_03e7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_03ec:  ldloc.s    V_29
+    IL_03ee:  newobj     instance void assembly/'Pipe #6 input at line 90@92-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_03f3:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_03f8:  ldsfld     class assembly/'Pipe #6 input at line 90@95-4' assembly/'Pipe #6 input at line 90@95-4'::@_instance
+    IL_03fd:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`3<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0402:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0407:  stloc.s    V_28
+    IL_0409:  ldloc.s    V_28
+    IL_040b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0410:  stsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::categories5@89
+    IL_0415:  ldc.r8     5.0999999999999996
+    IL_041e:  ldc.r8     4.0999999999999996
+    IL_0427:  ldc.r8     1.1000000000000001
+    IL_0430:  ldc.r8     3.1000000000000001
+    IL_0439:  ldc.r8     9.0999999999999996
+    IL_0442:  ldc.r8     8.0999999999999996
+    IL_044b:  ldc.r8     6.0999999999999996
+    IL_0454:  ldc.r8     7.0999999999999996
+    IL_045d:  ldc.r8     2.1000000000000001
+    IL_0466:  ldc.r8     0.10000000000000001
+    IL_046f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::get_Empty()
+    IL_0474:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0479:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_047e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0483:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0488:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_048d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0492:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0497:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_049c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_04a1:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_04a6:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> assembly::numbers2@99
+    IL_04ab:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_04b0:  stloc.s    V_30
+    IL_04b2:  ldloc.s    V_30
+    IL_04b4:  stloc.s    V_31
+    IL_04b6:  ldnull
+    IL_04b7:  ldc.i4.0
+    IL_04b8:  ldc.r8     0.0
+    IL_04c1:  newobj     instance void assembly/averageNum@100::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<float64>,
+                                                                                 int32,
+                                                                                 float64)
+    IL_04c6:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<float64,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_04cb:  stloc.s    V_32
+    IL_04cd:  ldsfld     class assembly/'averageNum@100-1' assembly/'averageNum@100-1'::@_instance
+    IL_04d2:  stloc.s    V_33
+    IL_04d4:  ldloc.s    V_32
+    IL_04d6:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<float64,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_04db:  stloc.s    V_34
+    IL_04dd:  ldloc.s    V_34
+    IL_04df:  box        class [runtime]System.Collections.Generic.IEnumerable`1<float64>
+    IL_04e4:  brtrue.s   IL_04f1
+
+    IL_04e6:  ldstr      "source"
+    IL_04eb:  newobj     instance void [netstandard]System.ArgumentNullException::.ctor(string)
+    IL_04f0:  throw
+
+    IL_04f1:  nop
+    IL_04f2:  ldloc.s    V_34
+    IL_04f4:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<float64>::GetEnumerator()
+    IL_04f9:  stloc.s    V_35
+    .try
+    {
+      IL_04fb:  ldc.r8     0.0
+      IL_0504:  stloc.s    V_37
+      IL_0506:  ldc.i4.0
+      IL_0507:  stloc.s    V_38
+      IL_0509:  br.s       IL_0524
+
+      IL_050b:  ldloc.s    V_37
+      IL_050d:  ldloc.s    V_33
+      IL_050f:  ldloc.s    V_35
+      IL_0511:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<float64>::get_Current()
+      IL_0516:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,float64>::Invoke(!0)
+      IL_051b:  add
+      IL_051c:  stloc.s    V_37
+      IL_051e:  ldloc.s    V_38
+      IL_0520:  ldc.i4.1
+      IL_0521:  add
+      IL_0522:  stloc.s    V_38
+      IL_0524:  ldloc.s    V_35
+      IL_0526:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+      IL_052b:  brtrue.s   IL_050b
+
+      IL_052d:  ldloc.s    V_38
+      IL_052f:  brtrue.s   IL_053c
+
+      IL_0531:  ldstr      "source"
+      IL_0536:  newobj     instance void [netstandard]System.InvalidOperationException::.ctor(string)
+      IL_053b:  throw
+
+      IL_053c:  nop
+      IL_053d:  ldloc.s    V_37
+      IL_053f:  stloc.s    V_39
+      IL_0541:  ldloc.s    V_38
+      IL_0543:  stloc.s    V_40
+      IL_0545:  ldloc.s    V_39
+      IL_0547:  ldloc.s    V_40
+      IL_0549:  conv.r8
+      IL_054a:  div
+      IL_054b:  stloc.s    V_36
+      IL_054d:  leave.s    IL_0565
+
+    }  
+    finally
+    {
+      IL_054f:  ldloc.s    V_35
+      IL_0551:  isinst     [runtime]System.IDisposable
+      IL_0556:  stloc.s    V_41
+      IL_0558:  ldloc.s    V_41
+      IL_055a:  brfalse.s  IL_0564
+
+      IL_055c:  ldloc.s    V_41
+      IL_055e:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+      IL_0563:  endfinally
+      IL_0564:  endfinally
+    }  
+    IL_0565:  ldloc.s    V_36
+    IL_0567:  stsfld     float64 assembly::averageNum@100
+    IL_056c:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0571:  stloc.s    V_42
+    IL_0573:  ldloc.s    V_42
+    IL_0575:  stloc.s    V_43
+    IL_0577:  ldloc.s    V_42
+    IL_0579:  ldloc.s    V_42
+    IL_057b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+    IL_0580:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0585:  ldloc.s    V_42
+    IL_0587:  newobj     instance void assembly/averageLength@105::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_058c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<string,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,float64>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0591:  stloc.s    V_44
+    IL_0593:  ldsfld     class assembly/'averageLength@107-1' assembly/'averageLength@107-1'::@_instance
+    IL_0598:  stloc.s    V_45
+    IL_059a:  ldloc.s    V_44
+    IL_059c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_05a1:  stloc.s    V_46
+    IL_05a3:  ldloc.s    V_46
+    IL_05a5:  box        class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,float64>>
+    IL_05aa:  brtrue.s   IL_05b7
+
+    IL_05ac:  ldstr      "source"
+    IL_05b1:  newobj     instance void [netstandard]System.ArgumentNullException::.ctor(string)
+    IL_05b6:  throw
+
+    IL_05b7:  nop
+    IL_05b8:  ldloc.s    V_46
+    IL_05ba:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,float64>>::GetEnumerator()
+    IL_05bf:  stloc.s    V_47
+    .try
+    {
+      IL_05c1:  ldc.r8     0.0
+      IL_05ca:  stloc.s    V_49
+      IL_05cc:  ldc.i4.0
+      IL_05cd:  stloc.s    V_50
+      IL_05cf:  br.s       IL_05ea
+
+      IL_05d1:  ldloc.s    V_49
+      IL_05d3:  ldloc.s    V_45
+      IL_05d5:  ldloc.s    V_47
+      IL_05d7:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<string,float64>>::get_Current()
+      IL_05dc:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,float64>,float64>::Invoke(!0)
+      IL_05e1:  add
+      IL_05e2:  stloc.s    V_49
+      IL_05e4:  ldloc.s    V_50
+      IL_05e6:  ldc.i4.1
+      IL_05e7:  add
+      IL_05e8:  stloc.s    V_50
+      IL_05ea:  ldloc.s    V_47
+      IL_05ec:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+      IL_05f1:  brtrue.s   IL_05d1
+
+      IL_05f3:  ldloc.s    V_50
+      IL_05f5:  brtrue.s   IL_0602
+
+      IL_05f7:  ldstr      "source"
+      IL_05fc:  newobj     instance void [netstandard]System.InvalidOperationException::.ctor(string)
+      IL_0601:  throw
+
+      IL_0602:  nop
+      IL_0603:  ldloc.s    V_49
+      IL_0605:  stloc.s    V_51
+      IL_0607:  ldloc.s    V_50
+      IL_0609:  stloc.s    V_52
+      IL_060b:  ldloc.s    V_51
+      IL_060d:  ldloc.s    V_52
+      IL_060f:  conv.r8
+      IL_0610:  div
+      IL_0611:  stloc.s    V_48
+      IL_0613:  leave.s    IL_062b
+
+    }  
+    finally
+    {
+      IL_0615:  ldloc.s    V_47
+      IL_0617:  isinst     [runtime]System.IDisposable
+      IL_061c:  stloc.s    V_53
+      IL_061e:  ldloc.s    V_53
+      IL_0620:  brfalse.s  IL_062a
+
+      IL_0622:  ldloc.s    V_53
+      IL_0624:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+      IL_0629:  endfinally
+      IL_062a:  endfinally
+    }  
+    IL_062b:  ldloc.s    V_48
+    IL_062d:  stsfld     float64 assembly::averageLength@103
+    IL_0632:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0637:  stloc.s    V_55
+    IL_0639:  ldloc.s    V_55
+    IL_063b:  ldloc.s    V_55
+    IL_063d:  ldloc.s    V_55
+    IL_063f:  ldloc.s    V_55
+    IL_0641:  ldloc.s    V_55
+    IL_0643:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_0648:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_064d:  ldloc.s    V_55
+    IL_064f:  newobj     instance void assembly/'Pipe #7 input at line 112@113'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0654:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0659:  ldsfld     class assembly/'Pipe #7 input at line 112@114-1' assembly/'Pipe #7 input at line 112@114-1'::@_instance
+    IL_065e:  ldsfld     class assembly/'Pipe #7 input at line 112@114-2' assembly/'Pipe #7 input at line 112@114-2'::@_instance
+    IL_0663:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_0668:  ldloc.s    V_55
+    IL_066a:  newobj     instance void assembly/'Pipe #7 input at line 112@114-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_066f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0674:  ldsfld     class assembly/'Pipe #7 input at line 112@116-4' assembly/'Pipe #7 input at line 112@116-4'::@_instance
+    IL_0679:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_067e:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0683:  stloc.s    V_54
+    IL_0685:  ldloc.s    V_54
+    IL_0687:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_068c:  stsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories6@111
+    IL_0691:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          factorsOf300()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_factorsOf300()
+  } 
+  .property int32 uniqueFactors()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_uniqueFactors()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property int32 numSum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_numSum()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property int32 totalChars()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_totalChars()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Tuple`2<string,int32>[]
+          categories()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,int32>[] assembly::get_categories()
+  } 
+  .property int32 minNum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_minNum()
+  } 
+  .property int32 shortestWord()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_shortestWord()
+  } 
+  .property class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[]
+          categories2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::get_categories2()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[]
+          categories3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::get_categories3()
+  } 
+  .property int32 maxNum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_maxNum()
+  } 
+  .property int32 longestLength()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_longestLength()
+  } 
+  .property class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[]
+          categories4()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::get_categories4()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[]
+          categories5()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::get_categories5()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>
+          numbers2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> assembly::get_numbers2()
+  } 
+  .property float64 averageNum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get float64 assembly::get_averageNum()
+  } 
+  .property float64 averageLength()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get float64 assembly::get_averageLength()
+  } 
+  .property class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[]
+          categories6()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::get_categories6()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOn.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
new file mode 100644
index 00000000000..151902f9f56
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
@@ -0,0 +1,7117 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern System.Linq
+{
+  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         
+  .ver 8:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 11@12'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_factorsOf300()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 11@12'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname numSum@21
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/numSum@21::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/numSum@21::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/numSum@21::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/numSum@21::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/numSum@21::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/numSum@21::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/numSum@21::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/numSum@21::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/numSum@21::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/numSum@21::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/numSum@21::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/numSum@21::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/numSum@21::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/numSum@21::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/numSum@21::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/numSum@21::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/numSum@21::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                              int32,
+                                                                              int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'numSum@22-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'numSum@22-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'numSum@22-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'numSum@22-1' assembly/'numSum@22-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname totalChars@30
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/totalChars@30::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/totalChars@30::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/totalChars@30::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/totalChars@30::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/totalChars@30::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/totalChars@30::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/totalChars@30::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/totalChars@30::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/totalChars@30::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/totalChars@30::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/totalChars@30::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/totalChars@30::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/totalChars@30::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/totalChars@30::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/totalChars@30::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/totalChars@30::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/totalChars@30::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                  int32,
+                                                                                  string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'totalChars@31-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'totalChars@31-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'totalChars@31-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'totalChars@31-1' assembly/'totalChars@31-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@39'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@39'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@39'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@40-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@40-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@40-1' assembly/'Pipe #2 input at line 38@40-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@40-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@40-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@40-2' assembly/'Pipe #2 input at line 38@40-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname sum@42
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/sum@42::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/sum@42::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/sum@42::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/sum@42::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/sum@42::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/sum@42::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/sum@42::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/sum@42::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/sum@42::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/sum@42::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/sum@42::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/sum@42::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/sum@42::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/sum@42::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/sum@42::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/sum@42::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/sum@42::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/sum@42::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/sum@42::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/sum@42::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                           int32,
+                                                                           class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'sum@43-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>
+  {
+    .field static assembly initonly class assembly/'sum@43-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'sum@43-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'sum@43-1' assembly/'sum@43-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@40-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               int32 V_1,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable> V_4,
+               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32> V_5,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_6,
+               class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> V_7,
+               int32 V_8,
+               int32 V_9,
+               class [runtime]System.IDisposable V_10)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  stloc.2
+      IL_0008:  ldloc.2
+      IL_0009:  stloc.3
+      IL_000a:  ldloc.0
+      IL_000b:  ldnull
+      IL_000c:  ldc.i4.0
+      IL_000d:  ldnull
+      IL_000e:  newobj     instance void assembly/sum@42::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                           int32,
+                                                                           class [Utils]Utils/Product)
+      IL_0013:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0018:  stloc.s    V_4
+      IL_001a:  ldsfld     class assembly/'sum@43-1' assembly/'sum@43-1'::@_instance
+      IL_001f:  stloc.s    V_5
+      IL_0021:  ldloc.s    V_4
+      IL_0023:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_0028:  stloc.s    V_6
+      IL_002a:  ldloc.s    V_6
+      IL_002c:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0031:  stloc.s    V_7
+      .try
+      {
+        IL_0033:  ldc.i4.0
+        IL_0034:  stloc.s    V_9
+        IL_0036:  br.s       IL_004b
+
+        IL_0038:  ldloc.s    V_9
+        IL_003a:  ldloc.s    V_5
+        IL_003c:  ldloc.s    V_7
+        IL_003e:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+        IL_0043:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>::Invoke(!0)
+        IL_0048:  add.ovf
+        IL_0049:  stloc.s    V_9
+        IL_004b:  ldloc.s    V_7
+        IL_004d:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+        IL_0052:  brtrue.s   IL_0038
+
+        IL_0054:  ldloc.s    V_9
+        IL_0056:  stloc.s    V_8
+        IL_0058:  leave.s    IL_0070
+
+      }  
+      finally
+      {
+        IL_005a:  ldloc.s    V_7
+        IL_005c:  isinst     [runtime]System.IDisposable
+        IL_0061:  stloc.s    V_10
+        IL_0063:  ldloc.s    V_10
+        IL_0065:  brfalse.s  IL_006f
+
+        IL_0067:  ldloc.s    V_10
+        IL_0069:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+        IL_006e:  endfinally
+        IL_006f:  endfinally
+      }  
+      IL_0070:  ldloc.s    V_8
+      IL_0072:  stloc.1
+      IL_0073:  ldarg.0
+      IL_0074:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@40-3'::builder@
+      IL_0079:  ldloc.0
+      IL_007a:  ldloc.1
+      IL_007b:  newobj     instance void class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>::.ctor(!0,
+                                                                                                                                                                          !1)
+      IL_0080:  tail.
+      IL_0082:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object>(!!0)
+      IL_0087:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@45-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,class [runtime]System.Tuple`2<string,int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@45-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,class [runtime]System.Tuple`2<string,int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,int32> Invoke(class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               int32 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,int32>::.ctor(!0,
+                                                                                                   !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@45-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@45-4' assembly/'Pipe #2 input at line 38@45-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname minNum@49
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/minNum@49::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/minNum@49::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/minNum@49::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/minNum@49::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/minNum@49::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/minNum@49::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/minNum@49::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/minNum@49::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/minNum@49::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/minNum@49::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/minNum@49::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/minNum@49::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/minNum@49::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/minNum@49::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/minNum@49::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/minNum@49::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/minNum@49::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                              int32,
+                                                                              int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'minNum@49-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'minNum@49-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'minNum@49-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'minNum@49-1' assembly/'minNum@49-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname shortestWord@52
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/shortestWord@52::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/shortestWord@52::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/shortestWord@52::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/shortestWord@52::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/shortestWord@52::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/shortestWord@52::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/shortestWord@52::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/shortestWord@52::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/shortestWord@52::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/shortestWord@52::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/shortestWord@52::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/shortestWord@52::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/shortestWord@52::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/shortestWord@52::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/shortestWord@52::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/shortestWord@52::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/shortestWord@52::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                    int32,
+                                                                                    string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'shortestWord@52-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'shortestWord@52-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'shortestWord@52-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'shortestWord@52-1' assembly/'shortestWord@52-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@57'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 56@57'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 56@57'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@58-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 56@58-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 56@58-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 56@58-1' assembly/'Pipe #3 input at line 56@58-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@58-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 56@58-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 56@58-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 56@58-2' assembly/'Pipe #3 input at line 56@58-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname min@59
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/min@59::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/min@59::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/min@59::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/min@59::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/min@59::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/min@59::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/min@59::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/min@59::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/min@59::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/min@59::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/min@59::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/min@59::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/min@59::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/min@59::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/min@59::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/min@59::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/min@59::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/min@59::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/min@59::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/min@59::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                           int32,
+                                                                           class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'min@59-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'min@59-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'min@59-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'min@59-1' assembly/'min@59-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@58-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 56@58-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  ldloc.0
+      IL_0008:  ldnull
+      IL_0009:  ldc.i4.0
+      IL_000a:  ldnull
+      IL_000b:  newobj     instance void assembly/min@59::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                           int32,
+                                                                           class [Utils]Utils/Product)
+      IL_0010:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0015:  ldsfld     class assembly/'min@59-1' assembly/'min@59-1'::@_instance
+      IL_001a:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MinBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,valuetype [runtime]System.Decimal>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_001f:  stloc.1
+      IL_0020:  ldarg.0
+      IL_0021:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 56@58-3'::builder@
+      IL_0026:  ldloc.0
+      IL_0027:  ldloc.1
+      IL_0028:  newobj     instance void class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                                                                                             !1)
+      IL_002d:  tail.
+      IL_002f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(!!0)
+      IL_0034:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@60-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 56@60-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                      !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 56@60-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 56@60-4' assembly/'Pipe #3 input at line 56@60-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@66'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 65@66'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 65@66'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@67-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 65@67-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 65@67-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 65@67-1' assembly/'Pipe #4 input at line 65@67-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@67-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 65@67-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 65@67-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 65@67-2' assembly/'Pipe #4 input at line 65@67-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class abstract auto autochar serializable sealed nested assembly beforefieldinit specialname 'min@68-2'
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method assembly static valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname cheapestProducts@69
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/cheapestProducts@69::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/cheapestProducts@69::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/cheapestProducts@69::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/cheapestProducts@69::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/cheapestProducts@69::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/cheapestProducts@69::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/cheapestProducts@69::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/cheapestProducts@69::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/cheapestProducts@69::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/cheapestProducts@69::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                        class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                        int32,
+                                                                                        class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'cheapestProducts@69-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field public valuetype [runtime]System.Decimal min
+    .method assembly specialname rtspecialname instance void  .ctor(valuetype [runtime]System.Decimal min) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      valuetype [runtime]System.Decimal assembly/'cheapestProducts@69-1'::min
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0006:  ldarg.0
+      IL_0007:  ldfld      valuetype [runtime]System.Decimal assembly/'cheapestProducts@69-1'::min
+      IL_000c:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                         valuetype [netstandard]System.Decimal)
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@67-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 65@67-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_2,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  ldnull
+      IL_0004:  ldftn      valuetype [runtime]System.Decimal assembly/'min@68-2'::Invoke(class [Utils]Utils/Product)
+      IL_000a:  newobj     instance void class [runtime]System.Func`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor(object,
+                                                                                                                                                         native int)
+      IL_000f:  call       valuetype [runtime]System.Decimal [System.Linq]System.Linq.Enumerable::Min<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                                                         class [runtime]System.Func`2<!!0,valuetype [runtime]System.Decimal>)
+      IL_0014:  stloc.1
+      IL_0015:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_001a:  stloc.3
+      IL_001b:  ldloc.3
+      IL_001c:  ldloc.0
+      IL_001d:  ldnull
+      IL_001e:  ldc.i4.0
+      IL_001f:  ldnull
+      IL_0020:  newobj     instance void assembly/cheapestProducts@69::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                        class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                        int32,
+                                                                                        class [Utils]Utils/Product)
+      IL_0025:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_002a:  ldloc.1
+      IL_002b:  newobj     instance void assembly/'cheapestProducts@69-1'::.ctor(valuetype [runtime]System.Decimal)
+      IL_0030:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_003a:  stloc.2
+      IL_003b:  ldarg.0
+      IL_003c:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 65@67-3'::builder@
+      IL_0041:  ldloc.0
+      IL_0042:  ldloc.1
+      IL_0043:  ldloc.2
+      IL_0044:  newobj     instance void class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                                                                                                                                        !1,
+                                                                                                                                                                                                                                                                                                        !2)
+      IL_0049:  tail.
+      IL_004b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(!!0)
+      IL_0050:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@70-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 65@70-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> Invoke(class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldarg.1
+      IL_000f:  call       instance !2 class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item3()
+      IL_0014:  stloc.2
+      IL_0015:  ldloc.0
+      IL_0016:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_001b:  ldloc.2
+      IL_001c:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                        !1)
+      IL_0021:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 65@70-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 65@70-4' assembly/'Pipe #4 input at line 65@70-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname maxNum@74
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/maxNum@74::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/maxNum@74::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxNum@74::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/maxNum@74::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/maxNum@74::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/maxNum@74::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/maxNum@74::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/maxNum@74::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/maxNum@74::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxNum@74::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/maxNum@74::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/maxNum@74::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/maxNum@74::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/maxNum@74::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxNum@74::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxNum@74::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/maxNum@74::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                              int32,
+                                                                              int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'maxNum@74-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'maxNum@74-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'maxNum@74-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'maxNum@74-1' assembly/'maxNum@74-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname longestLength@77
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/longestLength@77::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/longestLength@77::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/longestLength@77::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/longestLength@77::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/longestLength@77::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/longestLength@77::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/longestLength@77::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/longestLength@77::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/longestLength@77::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/longestLength@77::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/longestLength@77::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/longestLength@77::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/longestLength@77::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/longestLength@77::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/longestLength@77::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/longestLength@77::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/longestLength@77::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                     int32,
+                                                                                     string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'longestLength@77-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'longestLength@77-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'longestLength@77-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'longestLength@77-1' assembly/'longestLength@77-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@82'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #5 input at line 81@82'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #5 input at line 81@82'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@83-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 81@83-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 81@83-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 81@83-1' assembly/'Pipe #5 input at line 81@83-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@83-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 81@83-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 81@83-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 81@83-2' assembly/'Pipe #5 input at line 81@83-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname mostExpensivePrice@84
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensivePrice@84::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensivePrice@84::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/mostExpensivePrice@84::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/mostExpensivePrice@84::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/mostExpensivePrice@84::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensivePrice@84::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/mostExpensivePrice@84::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                          class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                          int32,
+                                                                                          class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'mostExpensivePrice@84-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'mostExpensivePrice@84-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'mostExpensivePrice@84-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'mostExpensivePrice@84-1' assembly/'mostExpensivePrice@84-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@83-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #5 input at line 81@83-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  ldloc.0
+      IL_0008:  ldnull
+      IL_0009:  ldc.i4.0
+      IL_000a:  ldnull
+      IL_000b:  newobj     instance void assembly/mostExpensivePrice@84::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                          class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                          int32,
+                                                                                          class [Utils]Utils/Product)
+      IL_0010:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0015:  ldsfld     class assembly/'mostExpensivePrice@84-1' assembly/'mostExpensivePrice@84-1'::@_instance
+      IL_001a:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MaxBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,valuetype [runtime]System.Decimal>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_001f:  stloc.1
+      IL_0020:  ldarg.0
+      IL_0021:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #5 input at line 81@83-3'::builder@
+      IL_0026:  ldloc.0
+      IL_0027:  ldloc.1
+      IL_0028:  newobj     instance void class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                                                                                             !1)
+      IL_002d:  tail.
+      IL_002f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(!!0)
+      IL_0034:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@85-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 81@85-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                      !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 81@85-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 81@85-4' assembly/'Pipe #5 input at line 81@85-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@91'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 90@91'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 90@91'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@92-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 90@92-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 90@92-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 90@92-1' assembly/'Pipe #6 input at line 90@92-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@92-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 90@92-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 90@92-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 90@92-2' assembly/'Pipe #6 input at line 90@92-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname maxPrice@93
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/maxPrice@93::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/maxPrice@93::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxPrice@93::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/maxPrice@93::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/maxPrice@93::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/maxPrice@93::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/maxPrice@93::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/maxPrice@93::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxPrice@93::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/maxPrice@93::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/maxPrice@93::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/maxPrice@93::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxPrice@93::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/maxPrice@93::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/maxPrice@93::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                int32,
+                                                                                class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'maxPrice@93-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'maxPrice@93-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'maxPrice@93-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'maxPrice@93-1' assembly/'maxPrice@93-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname mostExpensiveProducts@94
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/mostExpensiveProducts@94::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/mostExpensiveProducts@94::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                             class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                             int32,
+                                                                                             class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'mostExpensiveProducts@94-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field public valuetype [runtime]System.Decimal maxPrice
+    .method assembly specialname rtspecialname instance void  .ctor(valuetype [runtime]System.Decimal maxPrice) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      valuetype [runtime]System.Decimal assembly/'mostExpensiveProducts@94-1'::maxPrice
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0006:  ldarg.0
+      IL_0007:  ldfld      valuetype [runtime]System.Decimal assembly/'mostExpensiveProducts@94-1'::maxPrice
+      IL_000c:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                         valuetype [netstandard]System.Decimal)
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@92-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 90@92-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_2,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  ldloc.0
+      IL_0008:  ldnull
+      IL_0009:  ldc.i4.0
+      IL_000a:  ldnull
+      IL_000b:  newobj     instance void assembly/maxPrice@93::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                int32,
+                                                                                class [Utils]Utils/Product)
+      IL_0010:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0015:  ldsfld     class assembly/'maxPrice@93-1' assembly/'maxPrice@93-1'::@_instance
+      IL_001a:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MaxBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,valuetype [runtime]System.Decimal>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_001f:  stloc.1
+      IL_0020:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0025:  stloc.3
+      IL_0026:  ldloc.3
+      IL_0027:  ldloc.0
+      IL_0028:  ldnull
+      IL_0029:  ldc.i4.0
+      IL_002a:  ldnull
+      IL_002b:  newobj     instance void assembly/mostExpensiveProducts@94::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                             class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                             int32,
+                                                                                             class [Utils]Utils/Product)
+      IL_0030:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0035:  ldloc.1
+      IL_0036:  newobj     instance void assembly/'mostExpensiveProducts@94-1'::.ctor(valuetype [runtime]System.Decimal)
+      IL_003b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+      IL_0040:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_0045:  stloc.2
+      IL_0046:  ldarg.0
+      IL_0047:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 90@92-3'::builder@
+      IL_004c:  ldloc.0
+      IL_004d:  ldloc.1
+      IL_004e:  ldloc.2
+      IL_004f:  newobj     instance void class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                                                                                                                                        !1,
+                                                                                                                                                                                                                                                                                                        !2)
+      IL_0054:  tail.
+      IL_0056:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(!!0)
+      IL_005b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@95-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 90@95-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> Invoke(class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldarg.1
+      IL_000f:  call       instance !2 class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item3()
+      IL_0014:  stloc.2
+      IL_0015:  ldloc.0
+      IL_0016:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_001b:  ldloc.2
+      IL_001c:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                        !1)
+      IL_0021:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 90@95-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 90@95-4' assembly/'Pipe #6 input at line 90@95-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname averageNum@100
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<float64>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<float64> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public float64 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<float64> 'enum',
+                                 int32 pc,
+                                 float64 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/averageNum@100::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      float64 assembly/averageNum@100::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<float64>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<float64>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (float64 V_0,
+               float64 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averageNum@100::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> assembly::get_numbers2()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<float64>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/averageNum@100::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<float64>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/averageNum@100::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      float64 assembly/averageNum@100::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/averageNum@100::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<float64>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/averageNum@100::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.r8     0.0
+      IL_0095:  stfld      float64 assembly/averageNum@100::current
+      IL_009a:  ldc.i4.0
+      IL_009b:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averageNum@100::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_007e
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/averageNum@100::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/averageNum@100::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<float64>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/averageNum@100::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.r8     0.0
+        IL_0067:  stfld      float64 assembly/averageNum@100::current
+        IL_006c:  leave.s    IL_0078
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_006e:  castclass  [runtime]System.Exception
+        IL_0073:  stloc.1
+        IL_0074:  ldloc.1
+        IL_0075:  stloc.0
+        IL_0076:  leave.s    IL_0078
+
+      }  
+      IL_0078:  nop
+      IL_0079:  br         IL_0000
+
+      IL_007e:  ldloc.0
+      IL_007f:  brfalse.s  IL_0083
+
+      IL_0081:  ldloc.0
+      IL_0082:  throw
+
+      IL_0083:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averageNum@100::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance float64 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      float64 assembly/averageNum@100::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<float64> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.r8     0.0
+      IL_000b:  newobj     instance void assembly/averageNum@100::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<float64>,
+                                                                                   int32,
+                                                                                   float64)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'averageNum@100-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,float64>
+  {
+    .field static assembly initonly class assembly/'averageNum@100-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,float64>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance float64 Invoke(float64 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'averageNum@100-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'averageNum@100-1' assembly/'averageNum@100-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit averageLength@105
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/averageLength@105::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,object> Invoke(string _arg1) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (string V_0,
+               float64 V_1,
+               int32 V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0008:  stloc.2
+      IL_0009:  ldloc.2
+      IL_000a:  conv.r8
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/averageLength@105::builder@
+      IL_0012:  ldloc.0
+      IL_0013:  ldloc.1
+      IL_0014:  newobj     instance void class [runtime]System.Tuple`2<string,float64>::.ctor(!0,
+                                                                                                     !1)
+      IL_0019:  tail.
+      IL_001b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<string,float64>,object>(!!0)
+      IL_0020:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'averageLength@107-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,float64>,float64>
+  {
+    .field static assembly initonly class assembly/'averageLength@107-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,float64>,float64>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance float64 Invoke(class [runtime]System.Tuple`2<string,float64> tupledArg) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (string V_0,
+               float64 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<string,float64>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<string,float64>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'averageLength@107-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'averageLength@107-1' assembly/'averageLength@107-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@113'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 112@113'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 112@113'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@114-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 112@114-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 112@114-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 112@114-1' assembly/'Pipe #7 input at line 112@114-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@114-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 112@114-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 112@114-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 112@114-2' assembly/'Pipe #7 input at line 112@114-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname averagePrice@115
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/averagePrice@115::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/averagePrice@115::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averagePrice@115::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/averagePrice@115::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/averagePrice@115::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/averagePrice@115::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/averagePrice@115::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/averagePrice@115::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averagePrice@115::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/averagePrice@115::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/averagePrice@115::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/averagePrice@115::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averagePrice@115::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/averagePrice@115::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/averagePrice@115::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                     class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                     int32,
+                                                                                     class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'averagePrice@115-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'averagePrice@115-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'averagePrice@115-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'averagePrice@115-1' assembly/'averagePrice@115-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@114-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 112@114-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable> V_4,
+               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal> V_5,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_6,
+               string V_7,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_8,
+               string V_9,
+               class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> V_10,
+               valuetype [runtime]System.Decimal V_11,
+               valuetype [runtime]System.Decimal V_12,
+               int32 V_13,
+               string V_14,
+               valuetype [runtime]System.Decimal V_15,
+               int32 V_16,
+               class [runtime]System.IDisposable V_17)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  stloc.2
+      IL_0008:  ldloc.2
+      IL_0009:  stloc.3
+      IL_000a:  ldloc.0
+      IL_000b:  ldnull
+      IL_000c:  ldc.i4.0
+      IL_000d:  ldnull
+      IL_000e:  newobj     instance void assembly/averagePrice@115::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                     class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                     int32,
+                                                                                     class [Utils]Utils/Product)
+      IL_0013:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0018:  stloc.s    V_4
+      IL_001a:  ldsfld     class assembly/'averagePrice@115-1' assembly/'averagePrice@115-1'::@_instance
+      IL_001f:  stloc.s    V_5
+      IL_0021:  ldloc.s    V_4
+      IL_0023:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_0028:  stloc.s    V_6
+      IL_002a:  ldstr      "source"
+      IL_002f:  stloc.s    V_7
+      IL_0031:  ldloc.s    V_6
+      IL_0033:  stloc.s    V_8
+      IL_0035:  ldloc.s    V_8
+      IL_0037:  box        class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>
+      IL_003c:  brtrue.s   IL_004a
+
+      IL_003e:  ldloc.s    V_7
+      IL_0040:  stloc.s    V_9
+      IL_0042:  ldloc.s    V_9
+      IL_0044:  newobj     instance void [netstandard]System.ArgumentNullException::.ctor(string)
+      IL_0049:  throw
+
+      IL_004a:  nop
+      IL_004b:  ldloc.s    V_6
+      IL_004d:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0052:  stloc.s    V_10
+      .try
+      {
+        IL_0054:  ldc.i4.0
+        IL_0055:  ldc.i4.0
+        IL_0056:  ldc.i4.0
+        IL_0057:  ldc.i4.0
+        IL_0058:  ldc.i4.0
+        IL_0059:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                              int32,
+                                                                              int32,
+                                                                              bool,
+                                                                              uint8)
+        IL_005e:  stloc.s    V_12
+        IL_0060:  ldc.i4.0
+        IL_0061:  stloc.s    V_13
+        IL_0063:  br.s       IL_0082
+
+        IL_0065:  ldloc.s    V_12
+        IL_0067:  ldloc.s    V_5
+        IL_0069:  ldloc.s    V_10
+        IL_006b:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+        IL_0070:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::Invoke(!0)
+        IL_0075:  call       valuetype [netstandard]System.Decimal [netstandard]System.Decimal::op_Addition(valuetype [netstandard]System.Decimal,
+                                                                                                            valuetype [netstandard]System.Decimal)
+        IL_007a:  stloc.s    V_12
+        IL_007c:  ldloc.s    V_13
+        IL_007e:  ldc.i4.1
+        IL_007f:  add
+        IL_0080:  stloc.s    V_13
+        IL_0082:  ldloc.s    V_10
+        IL_0084:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+        IL_0089:  brtrue.s   IL_0065
+
+        IL_008b:  ldloc.s    V_13
+        IL_008d:  brtrue.s   IL_009e
+
+        IL_008f:  ldstr      "source"
+        IL_0094:  stloc.s    V_14
+        IL_0096:  ldloc.s    V_14
+        IL_0098:  newobj     instance void [netstandard]System.InvalidOperationException::.ctor(string)
+        IL_009d:  throw
+
+        IL_009e:  nop
+        IL_009f:  ldloc.s    V_12
+        IL_00a1:  stloc.s    V_15
+        IL_00a3:  ldloc.s    V_13
+        IL_00a5:  stloc.s    V_16
+        IL_00a7:  ldloc.s    V_15
+        IL_00a9:  ldloc.s    V_16
+        IL_00ab:  call       valuetype [netstandard]System.Decimal [netstandard]System.Convert::ToDecimal(int32)
+        IL_00b0:  call       valuetype [netstandard]System.Decimal [netstandard]System.Decimal::Divide(valuetype [netstandard]System.Decimal,
+                                                                                                       valuetype [netstandard]System.Decimal)
+        IL_00b5:  stloc.s    V_11
+        IL_00b7:  leave.s    IL_00cf
+
+      }  
+      finally
+      {
+        IL_00b9:  ldloc.s    V_10
+        IL_00bb:  isinst     [runtime]System.IDisposable
+        IL_00c0:  stloc.s    V_17
+        IL_00c2:  ldloc.s    V_17
+        IL_00c4:  brfalse.s  IL_00ce
+
+        IL_00c6:  ldloc.s    V_17
+        IL_00c8:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+        IL_00cd:  endfinally
+        IL_00ce:  endfinally
+      }  
+      IL_00cf:  ldloc.s    V_11
+      IL_00d1:  stloc.1
+      IL_00d2:  ldarg.0
+      IL_00d3:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 112@114-3'::builder@
+      IL_00d8:  ldloc.0
+      IL_00d9:  ldloc.1
+      IL_00da:  newobj     instance void class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                                                                                             !1)
+      IL_00df:  tail.
+      IL_00e1:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(!!0)
+      IL_00e6:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@116-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 112@116-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                      !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 112@116-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 112@116-4' assembly/'Pipe #7 input at line 112@116-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> factorsOf300@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 uniqueFactors@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 numSum@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@26
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 totalChars@28
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@35
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,int32>[] categories@37
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 minNum@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 shortestWord@52
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] categories2@55
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] categories3@64
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 maxNum@74
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 longestLength@77
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] categories4@80
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] categories5@89
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> numbers2@99
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly float64 averageNum@100
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly float64 averageLength@103
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] categories6@111
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_factorsOf300() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::factorsOf300@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_uniqueFactors() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::uniqueFactors@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@17
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_numSum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::numSum@19
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@26
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_totalChars() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::totalChars@28
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@35
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,int32>[] get_categories() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,int32>[] assembly::categories@37
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_minNum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::minNum@49
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_shortestWord() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::shortestWord@52
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] get_categories2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories2@55
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] get_categories3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::categories3@64
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_maxNum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::maxNum@74
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_longestLength() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::longestLength@77
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] get_categories4() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories4@80
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] get_categories5() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::categories5@89
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> get_numbers2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> assembly::numbers2@99
+    IL_0005:  ret
+  } 
+
+  .method public specialname static float64 get_averageNum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     float64 assembly::averageNum@100
+    IL_0005:  ret
+  } 
+
+  .method public specialname static float64 get_averageLength() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     float64 assembly::averageLength@103
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] get_categories6() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories6@111
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32> V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_6,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_7,
+             int32 V_8,
+             int32 V_9,
+             class [runtime]System.IDisposable V_10,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_11,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_12,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable> V_13,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32> V_14,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_15,
+             class [runtime]System.Collections.Generic.IEnumerator`1<string> V_16,
+             int32 V_17,
+             int32 V_18,
+             class [runtime]System.IDisposable V_19,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> V_20,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_21,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>> V_22,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_23,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>> V_24,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_25,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>> V_26,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_27,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>> V_28,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_29,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_30,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_31,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<float64,class [runtime]System.Collections.IEnumerable> V_32,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,float64> V_33,
+             class [runtime]System.Collections.Generic.IEnumerable`1<float64> V_34,
+             string V_35,
+             class [runtime]System.Collections.Generic.IEnumerable`1<float64> V_36,
+             string V_37,
+             class [runtime]System.Collections.Generic.IEnumerator`1<float64> V_38,
+             float64 V_39,
+             float64 V_40,
+             int32 V_41,
+             string V_42,
+             float64 V_43,
+             int32 V_44,
+             class [runtime]System.IDisposable V_45,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_46,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_47,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,class [runtime]System.Collections.IEnumerable> V_48,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,float64>,float64> V_49,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,float64>> V_50,
+             string V_51,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,float64>> V_52,
+             string V_53,
+             class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<string,float64>> V_54,
+             float64 V_55,
+             float64 V_56,
+             int32 V_57,
+             string V_58,
+             float64 V_59,
+             int32 V_60,
+             class [runtime]System.IDisposable V_61,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>> V_62,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_63)
+    IL_0000:  ldc.i4.2
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  ldc.i4.5
+    IL_0004:  ldc.i4.5
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::factorsOf300@8
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_002d:  stloc.1
+    IL_002e:  ldloc.1
+    IL_002f:  ldnull
+    IL_0030:  ldc.i4.0
+    IL_0031:  ldc.i4.0
+    IL_0032:  newobj     instance void assembly/'Pipe #1 input at line 11@12'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                int32,
+                                                                                                int32)
+    IL_0037:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_003c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Distinct<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_0041:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0046:  stloc.0
+    IL_0047:  ldloc.0
+    IL_0048:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_004d:  stsfld     int32 assembly::uniqueFactors@10
+    IL_0052:  ldc.i4.5
+    IL_0053:  ldc.i4.4
+    IL_0054:  ldc.i4.1
+    IL_0055:  ldc.i4.3
+    IL_0056:  ldc.i4.s   9
+    IL_0058:  ldc.i4.8
+    IL_0059:  ldc.i4.6
+    IL_005a:  ldc.i4.7
+    IL_005b:  ldc.i4.2
+    IL_005c:  ldc.i4.0
+    IL_005d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0062:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0067:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_006c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0071:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0076:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_007b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0080:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0085:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_008a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_008f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0094:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@17
+    IL_0099:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_009e:  stloc.2
+    IL_009f:  ldloc.2
+    IL_00a0:  stloc.3
+    IL_00a1:  ldnull
+    IL_00a2:  ldc.i4.0
+    IL_00a3:  ldc.i4.0
+    IL_00a4:  newobj     instance void assembly/numSum@21::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                            int32,
+                                                                            int32)
+    IL_00a9:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00ae:  stloc.s    V_4
+    IL_00b0:  ldsfld     class assembly/'numSum@22-1' assembly/'numSum@22-1'::@_instance
+    IL_00b5:  stloc.s    V_5
+    IL_00b7:  ldloc.s    V_4
+    IL_00b9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00be:  stloc.s    V_6
+    IL_00c0:  ldloc.s    V_6
+    IL_00c2:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_00c7:  stloc.s    V_7
+    .try
+    {
+      IL_00c9:  ldc.i4.0
+      IL_00ca:  stloc.s    V_9
+      IL_00cc:  br.s       IL_00e1
+
+      IL_00ce:  ldloc.s    V_9
+      IL_00d0:  ldloc.s    V_5
+      IL_00d2:  ldloc.s    V_7
+      IL_00d4:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_00d9:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::Invoke(!0)
+      IL_00de:  add.ovf
+      IL_00df:  stloc.s    V_9
+      IL_00e1:  ldloc.s    V_7
+      IL_00e3:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+      IL_00e8:  brtrue.s   IL_00ce
+
+      IL_00ea:  ldloc.s    V_9
+      IL_00ec:  stloc.s    V_8
+      IL_00ee:  leave.s    IL_0106
+
+    }  
+    finally
+    {
+      IL_00f0:  ldloc.s    V_7
+      IL_00f2:  isinst     [runtime]System.IDisposable
+      IL_00f7:  stloc.s    V_10
+      IL_00f9:  ldloc.s    V_10
+      IL_00fb:  brfalse.s  IL_0105
+
+      IL_00fd:  ldloc.s    V_10
+      IL_00ff:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+      IL_0104:  endfinally
+      IL_0105:  endfinally
+    }  
+    IL_0106:  ldloc.s    V_8
+    IL_0108:  stsfld     int32 assembly::numSum@19
+    IL_010d:  ldstr      "cherry"
+    IL_0112:  ldstr      "apple"
+    IL_0117:  ldstr      "blueberry"
+    IL_011c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0121:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0126:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_012b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0130:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@26
+    IL_0135:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_013a:  stloc.s    V_11
+    IL_013c:  ldloc.s    V_11
+    IL_013e:  stloc.s    V_12
+    IL_0140:  ldnull
+    IL_0141:  ldc.i4.0
+    IL_0142:  ldnull
+    IL_0143:  newobj     instance void assembly/totalChars@30::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                int32,
+                                                                                string)
+    IL_0148:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_014d:  stloc.s    V_13
+    IL_014f:  ldsfld     class assembly/'totalChars@31-1' assembly/'totalChars@31-1'::@_instance
+    IL_0154:  stloc.s    V_14
+    IL_0156:  ldloc.s    V_13
+    IL_0158:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_015d:  stloc.s    V_15
+    IL_015f:  ldloc.s    V_15
+    IL_0161:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+    IL_0166:  stloc.s    V_16
+    .try
+    {
+      IL_0168:  ldc.i4.0
+      IL_0169:  stloc.s    V_18
+      IL_016b:  br.s       IL_0180
+
+      IL_016d:  ldloc.s    V_18
+      IL_016f:  ldloc.s    V_14
+      IL_0171:  ldloc.s    V_16
+      IL_0173:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_0178:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::Invoke(!0)
+      IL_017d:  add.ovf
+      IL_017e:  stloc.s    V_18
+      IL_0180:  ldloc.s    V_16
+      IL_0182:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+      IL_0187:  brtrue.s   IL_016d
+
+      IL_0189:  ldloc.s    V_18
+      IL_018b:  stloc.s    V_17
+      IL_018d:  leave.s    IL_01a5
+
+    }  
+    finally
+    {
+      IL_018f:  ldloc.s    V_16
+      IL_0191:  isinst     [runtime]System.IDisposable
+      IL_0196:  stloc.s    V_19
+      IL_0198:  ldloc.s    V_19
+      IL_019a:  brfalse.s  IL_01a4
+
+      IL_019c:  ldloc.s    V_19
+      IL_019e:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+      IL_01a3:  endfinally
+      IL_01a4:  endfinally
+    }  
+    IL_01a5:  ldloc.s    V_17
+    IL_01a7:  stsfld     int32 assembly::totalChars@28
+    IL_01ac:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_01b1:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@35
+    IL_01b6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_01bb:  stloc.s    V_21
+    IL_01bd:  ldloc.s    V_21
+    IL_01bf:  ldloc.s    V_21
+    IL_01c1:  ldloc.s    V_21
+    IL_01c3:  ldloc.s    V_21
+    IL_01c5:  ldloc.s    V_21
+    IL_01c7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_01cc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01d1:  ldloc.s    V_21
+    IL_01d3:  newobj     instance void assembly/'Pipe #2 input at line 38@39'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01dd:  ldsfld     class assembly/'Pipe #2 input at line 38@40-1' assembly/'Pipe #2 input at line 38@40-1'::@_instance
+    IL_01e2:  ldsfld     class assembly/'Pipe #2 input at line 38@40-2' assembly/'Pipe #2 input at line 38@40-2'::@_instance
+    IL_01e7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_01ec:  ldloc.s    V_21
+    IL_01ee:  newobj     instance void assembly/'Pipe #2 input at line 38@40-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01f3:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01f8:  ldsfld     class assembly/'Pipe #2 input at line 38@45-4' assembly/'Pipe #2 input at line 38@45-4'::@_instance
+    IL_01fd:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,int32>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0202:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,int32>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0207:  stloc.s    V_20
+    IL_0209:  ldloc.s    V_20
+    IL_020b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,int32>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0210:  stsfld     class [runtime]System.Tuple`2<string,int32>[] assembly::categories@37
+    IL_0215:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_021a:  ldnull
+    IL_021b:  ldc.i4.0
+    IL_021c:  ldc.i4.0
+    IL_021d:  newobj     instance void assembly/minNum@49::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                            int32,
+                                                                            int32)
+    IL_0222:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0227:  ldsfld     class assembly/'minNum@49-1' assembly/'minNum@49-1'::@_instance
+    IL_022c:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MinBy<int32,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0231:  stsfld     int32 assembly::minNum@49
+    IL_0236:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_023b:  ldnull
+    IL_023c:  ldc.i4.0
+    IL_023d:  ldnull
+    IL_023e:  newobj     instance void assembly/shortestWord@52::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                  int32,
+                                                                                  string)
+    IL_0243:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0248:  ldsfld     class assembly/'shortestWord@52-1' assembly/'shortestWord@52-1'::@_instance
+    IL_024d:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MinBy<string,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0252:  stsfld     int32 assembly::shortestWord@52
+    IL_0257:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_025c:  stloc.s    V_23
+    IL_025e:  ldloc.s    V_23
+    IL_0260:  ldloc.s    V_23
+    IL_0262:  ldloc.s    V_23
+    IL_0264:  ldloc.s    V_23
+    IL_0266:  ldloc.s    V_23
+    IL_0268:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_026d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0272:  ldloc.s    V_23
+    IL_0274:  newobj     instance void assembly/'Pipe #3 input at line 56@57'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0279:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_027e:  ldsfld     class assembly/'Pipe #3 input at line 56@58-1' assembly/'Pipe #3 input at line 56@58-1'::@_instance
+    IL_0283:  ldsfld     class assembly/'Pipe #3 input at line 56@58-2' assembly/'Pipe #3 input at line 56@58-2'::@_instance
+    IL_0288:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_028d:  ldloc.s    V_23
+    IL_028f:  newobj     instance void assembly/'Pipe #3 input at line 56@58-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0294:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0299:  ldsfld     class assembly/'Pipe #3 input at line 56@60-4' assembly/'Pipe #3 input at line 56@60-4'::@_instance
+    IL_029e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_02a3:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_02a8:  stloc.s    V_22
+    IL_02aa:  ldloc.s    V_22
+    IL_02ac:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_02b1:  stsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories2@55
+    IL_02b6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_02bb:  stloc.s    V_25
+    IL_02bd:  ldloc.s    V_25
+    IL_02bf:  ldloc.s    V_25
+    IL_02c1:  ldloc.s    V_25
+    IL_02c3:  ldloc.s    V_25
+    IL_02c5:  ldloc.s    V_25
+    IL_02c7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_02cc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_02d1:  ldloc.s    V_25
+    IL_02d3:  newobj     instance void assembly/'Pipe #4 input at line 65@66'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_02d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_02dd:  ldsfld     class assembly/'Pipe #4 input at line 65@67-1' assembly/'Pipe #4 input at line 65@67-1'::@_instance
+    IL_02e2:  ldsfld     class assembly/'Pipe #4 input at line 65@67-2' assembly/'Pipe #4 input at line 65@67-2'::@_instance
+    IL_02e7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_02ec:  ldloc.s    V_25
+    IL_02ee:  newobj     instance void assembly/'Pipe #4 input at line 65@67-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_02f3:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_02f8:  ldsfld     class assembly/'Pipe #4 input at line 65@70-4' assembly/'Pipe #4 input at line 65@70-4'::@_instance
+    IL_02fd:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0302:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0307:  stloc.s    V_24
+    IL_0309:  ldloc.s    V_24
+    IL_030b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0310:  stsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::categories3@64
+    IL_0315:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_031a:  ldnull
+    IL_031b:  ldc.i4.0
+    IL_031c:  ldc.i4.0
+    IL_031d:  newobj     instance void assembly/maxNum@74::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                            int32,
+                                                                            int32)
+    IL_0322:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0327:  ldsfld     class assembly/'maxNum@74-1' assembly/'maxNum@74-1'::@_instance
+    IL_032c:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MaxBy<int32,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0331:  stsfld     int32 assembly::maxNum@74
+    IL_0336:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_033b:  ldnull
+    IL_033c:  ldc.i4.0
+    IL_033d:  ldnull
+    IL_033e:  newobj     instance void assembly/longestLength@77::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                   int32,
+                                                                                   string)
+    IL_0343:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0348:  ldsfld     class assembly/'longestLength@77-1' assembly/'longestLength@77-1'::@_instance
+    IL_034d:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MaxBy<string,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0352:  stsfld     int32 assembly::longestLength@77
+    IL_0357:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_035c:  stloc.s    V_27
+    IL_035e:  ldloc.s    V_27
+    IL_0360:  ldloc.s    V_27
+    IL_0362:  ldloc.s    V_27
+    IL_0364:  ldloc.s    V_27
+    IL_0366:  ldloc.s    V_27
+    IL_0368:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_036d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0372:  ldloc.s    V_27
+    IL_0374:  newobj     instance void assembly/'Pipe #5 input at line 81@82'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0379:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_037e:  ldsfld     class assembly/'Pipe #5 input at line 81@83-1' assembly/'Pipe #5 input at line 81@83-1'::@_instance
+    IL_0383:  ldsfld     class assembly/'Pipe #5 input at line 81@83-2' assembly/'Pipe #5 input at line 81@83-2'::@_instance
+    IL_0388:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_038d:  ldloc.s    V_27
+    IL_038f:  newobj     instance void assembly/'Pipe #5 input at line 81@83-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0394:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0399:  ldsfld     class assembly/'Pipe #5 input at line 81@85-4' assembly/'Pipe #5 input at line 81@85-4'::@_instance
+    IL_039e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_03a3:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_03a8:  stloc.s    V_26
+    IL_03aa:  ldloc.s    V_26
+    IL_03ac:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_03b1:  stsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories4@80
+    IL_03b6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_03bb:  stloc.s    V_29
+    IL_03bd:  ldloc.s    V_29
+    IL_03bf:  ldloc.s    V_29
+    IL_03c1:  ldloc.s    V_29
+    IL_03c3:  ldloc.s    V_29
+    IL_03c5:  ldloc.s    V_29
+    IL_03c7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_03cc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_03d1:  ldloc.s    V_29
+    IL_03d3:  newobj     instance void assembly/'Pipe #6 input at line 90@91'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_03d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_03dd:  ldsfld     class assembly/'Pipe #6 input at line 90@92-1' assembly/'Pipe #6 input at line 90@92-1'::@_instance
+    IL_03e2:  ldsfld     class assembly/'Pipe #6 input at line 90@92-2' assembly/'Pipe #6 input at line 90@92-2'::@_instance
+    IL_03e7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_03ec:  ldloc.s    V_29
+    IL_03ee:  newobj     instance void assembly/'Pipe #6 input at line 90@92-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_03f3:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_03f8:  ldsfld     class assembly/'Pipe #6 input at line 90@95-4' assembly/'Pipe #6 input at line 90@95-4'::@_instance
+    IL_03fd:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0402:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0407:  stloc.s    V_28
+    IL_0409:  ldloc.s    V_28
+    IL_040b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0410:  stsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::categories5@89
+    IL_0415:  ldc.r8     5.0999999999999996
+    IL_041e:  ldc.r8     4.0999999999999996
+    IL_0427:  ldc.r8     1.1000000000000001
+    IL_0430:  ldc.r8     3.1000000000000001
+    IL_0439:  ldc.r8     9.0999999999999996
+    IL_0442:  ldc.r8     8.0999999999999996
+    IL_044b:  ldc.r8     6.0999999999999996
+    IL_0454:  ldc.r8     7.0999999999999996
+    IL_045d:  ldc.r8     2.1000000000000001
+    IL_0466:  ldc.r8     0.10000000000000001
+    IL_046f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::get_Empty()
+    IL_0474:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0479:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_047e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0483:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0488:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_048d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0492:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0497:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_049c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_04a1:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_04a6:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> assembly::numbers2@99
+    IL_04ab:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_04b0:  stloc.s    V_30
+    IL_04b2:  ldloc.s    V_30
+    IL_04b4:  stloc.s    V_31
+    IL_04b6:  ldnull
+    IL_04b7:  ldc.i4.0
+    IL_04b8:  ldc.r8     0.0
+    IL_04c1:  newobj     instance void assembly/averageNum@100::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<float64>,
+                                                                                 int32,
+                                                                                 float64)
+    IL_04c6:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<float64,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_04cb:  stloc.s    V_32
+    IL_04cd:  ldsfld     class assembly/'averageNum@100-1' assembly/'averageNum@100-1'::@_instance
+    IL_04d2:  stloc.s    V_33
+    IL_04d4:  ldloc.s    V_32
+    IL_04d6:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<float64,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_04db:  stloc.s    V_34
+    IL_04dd:  ldstr      "source"
+    IL_04e2:  stloc.s    V_35
+    IL_04e4:  ldloc.s    V_34
+    IL_04e6:  stloc.s    V_36
+    IL_04e8:  ldloc.s    V_36
+    IL_04ea:  box        class [runtime]System.Collections.Generic.IEnumerable`1<float64>
+    IL_04ef:  brtrue.s   IL_04fd
+
+    IL_04f1:  ldloc.s    V_35
+    IL_04f3:  stloc.s    V_37
+    IL_04f5:  ldloc.s    V_37
+    IL_04f7:  newobj     instance void [netstandard]System.ArgumentNullException::.ctor(string)
+    IL_04fc:  throw
+
+    IL_04fd:  nop
+    IL_04fe:  ldloc.s    V_34
+    IL_0500:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<float64>::GetEnumerator()
+    IL_0505:  stloc.s    V_38
+    .try
+    {
+      IL_0507:  ldc.r8     0.0
+      IL_0510:  stloc.s    V_40
+      IL_0512:  ldc.i4.0
+      IL_0513:  stloc.s    V_41
+      IL_0515:  br.s       IL_0530
+
+      IL_0517:  ldloc.s    V_40
+      IL_0519:  ldloc.s    V_33
+      IL_051b:  ldloc.s    V_38
+      IL_051d:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<float64>::get_Current()
+      IL_0522:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,float64>::Invoke(!0)
+      IL_0527:  add
+      IL_0528:  stloc.s    V_40
+      IL_052a:  ldloc.s    V_41
+      IL_052c:  ldc.i4.1
+      IL_052d:  add
+      IL_052e:  stloc.s    V_41
+      IL_0530:  ldloc.s    V_38
+      IL_0532:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+      IL_0537:  brtrue.s   IL_0517
+
+      IL_0539:  ldloc.s    V_41
+      IL_053b:  brtrue.s   IL_054c
+
+      IL_053d:  ldstr      "source"
+      IL_0542:  stloc.s    V_42
+      IL_0544:  ldloc.s    V_42
+      IL_0546:  newobj     instance void [netstandard]System.InvalidOperationException::.ctor(string)
+      IL_054b:  throw
+
+      IL_054c:  nop
+      IL_054d:  ldloc.s    V_40
+      IL_054f:  stloc.s    V_43
+      IL_0551:  ldloc.s    V_41
+      IL_0553:  stloc.s    V_44
+      IL_0555:  ldloc.s    V_43
+      IL_0557:  ldloc.s    V_44
+      IL_0559:  conv.r8
+      IL_055a:  div
+      IL_055b:  stloc.s    V_39
+      IL_055d:  leave.s    IL_0575
+
+    }  
+    finally
+    {
+      IL_055f:  ldloc.s    V_38
+      IL_0561:  isinst     [runtime]System.IDisposable
+      IL_0566:  stloc.s    V_45
+      IL_0568:  ldloc.s    V_45
+      IL_056a:  brfalse.s  IL_0574
+
+      IL_056c:  ldloc.s    V_45
+      IL_056e:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+      IL_0573:  endfinally
+      IL_0574:  endfinally
+    }  
+    IL_0575:  ldloc.s    V_39
+    IL_0577:  stsfld     float64 assembly::averageNum@100
+    IL_057c:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0581:  stloc.s    V_46
+    IL_0583:  ldloc.s    V_46
+    IL_0585:  stloc.s    V_47
+    IL_0587:  ldloc.s    V_46
+    IL_0589:  ldloc.s    V_46
+    IL_058b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+    IL_0590:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0595:  ldloc.s    V_46
+    IL_0597:  newobj     instance void assembly/averageLength@105::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_059c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<string,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,float64>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_05a1:  stloc.s    V_48
+    IL_05a3:  ldsfld     class assembly/'averageLength@107-1' assembly/'averageLength@107-1'::@_instance
+    IL_05a8:  stloc.s    V_49
+    IL_05aa:  ldloc.s    V_48
+    IL_05ac:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_05b1:  stloc.s    V_50
+    IL_05b3:  ldstr      "source"
+    IL_05b8:  stloc.s    V_51
+    IL_05ba:  ldloc.s    V_50
+    IL_05bc:  stloc.s    V_52
+    IL_05be:  ldloc.s    V_52
+    IL_05c0:  box        class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,float64>>
+    IL_05c5:  brtrue.s   IL_05d3
+
+    IL_05c7:  ldloc.s    V_51
+    IL_05c9:  stloc.s    V_53
+    IL_05cb:  ldloc.s    V_53
+    IL_05cd:  newobj     instance void [netstandard]System.ArgumentNullException::.ctor(string)
+    IL_05d2:  throw
+
+    IL_05d3:  nop
+    IL_05d4:  ldloc.s    V_50
+    IL_05d6:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,float64>>::GetEnumerator()
+    IL_05db:  stloc.s    V_54
+    .try
+    {
+      IL_05dd:  ldc.r8     0.0
+      IL_05e6:  stloc.s    V_56
+      IL_05e8:  ldc.i4.0
+      IL_05e9:  stloc.s    V_57
+      IL_05eb:  br.s       IL_0606
+
+      IL_05ed:  ldloc.s    V_56
+      IL_05ef:  ldloc.s    V_49
+      IL_05f1:  ldloc.s    V_54
+      IL_05f3:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<string,float64>>::get_Current()
+      IL_05f8:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,float64>,float64>::Invoke(!0)
+      IL_05fd:  add
+      IL_05fe:  stloc.s    V_56
+      IL_0600:  ldloc.s    V_57
+      IL_0602:  ldc.i4.1
+      IL_0603:  add
+      IL_0604:  stloc.s    V_57
+      IL_0606:  ldloc.s    V_54
+      IL_0608:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+      IL_060d:  brtrue.s   IL_05ed
+
+      IL_060f:  ldloc.s    V_57
+      IL_0611:  brtrue.s   IL_0622
+
+      IL_0613:  ldstr      "source"
+      IL_0618:  stloc.s    V_58
+      IL_061a:  ldloc.s    V_58
+      IL_061c:  newobj     instance void [netstandard]System.InvalidOperationException::.ctor(string)
+      IL_0621:  throw
+
+      IL_0622:  nop
+      IL_0623:  ldloc.s    V_56
+      IL_0625:  stloc.s    V_59
+      IL_0627:  ldloc.s    V_57
+      IL_0629:  stloc.s    V_60
+      IL_062b:  ldloc.s    V_59
+      IL_062d:  ldloc.s    V_60
+      IL_062f:  conv.r8
+      IL_0630:  div
+      IL_0631:  stloc.s    V_55
+      IL_0633:  leave.s    IL_064b
+
+    }  
+    finally
+    {
+      IL_0635:  ldloc.s    V_54
+      IL_0637:  isinst     [runtime]System.IDisposable
+      IL_063c:  stloc.s    V_61
+      IL_063e:  ldloc.s    V_61
+      IL_0640:  brfalse.s  IL_064a
+
+      IL_0642:  ldloc.s    V_61
+      IL_0644:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+      IL_0649:  endfinally
+      IL_064a:  endfinally
+    }  
+    IL_064b:  ldloc.s    V_55
+    IL_064d:  stsfld     float64 assembly::averageLength@103
+    IL_0652:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0657:  stloc.s    V_63
+    IL_0659:  ldloc.s    V_63
+    IL_065b:  ldloc.s    V_63
+    IL_065d:  ldloc.s    V_63
+    IL_065f:  ldloc.s    V_63
+    IL_0661:  ldloc.s    V_63
+    IL_0663:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_0668:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_066d:  ldloc.s    V_63
+    IL_066f:  newobj     instance void assembly/'Pipe #7 input at line 112@113'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0674:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0679:  ldsfld     class assembly/'Pipe #7 input at line 112@114-1' assembly/'Pipe #7 input at line 112@114-1'::@_instance
+    IL_067e:  ldsfld     class assembly/'Pipe #7 input at line 112@114-2' assembly/'Pipe #7 input at line 112@114-2'::@_instance
+    IL_0683:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_0688:  ldloc.s    V_63
+    IL_068a:  newobj     instance void assembly/'Pipe #7 input at line 112@114-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_068f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0694:  ldsfld     class assembly/'Pipe #7 input at line 112@116-4' assembly/'Pipe #7 input at line 112@116-4'::@_instance
+    IL_0699:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_069e:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_06a3:  stloc.s    V_62
+    IL_06a5:  ldloc.s    V_62
+    IL_06a7:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_06ac:  stsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories6@111
+    IL_06b1:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          factorsOf300()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_factorsOf300()
+  } 
+  .property int32 uniqueFactors()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_uniqueFactors()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property int32 numSum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_numSum()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property int32 totalChars()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_totalChars()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Tuple`2<string,int32>[]
+          categories()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,int32>[] assembly::get_categories()
+  } 
+  .property int32 minNum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_minNum()
+  } 
+  .property int32 shortestWord()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_shortestWord()
+  } 
+  .property class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[]
+          categories2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::get_categories2()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[]
+          categories3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::get_categories3()
+  } 
+  .property int32 maxNum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_maxNum()
+  } 
+  .property int32 longestLength()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_longestLength()
+  } 
+  .property class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[]
+          categories4()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::get_categories4()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[]
+          categories5()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::get_categories5()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>
+          numbers2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> assembly::get_numbers2()
+  } 
+  .property float64 averageNum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get float64 assembly::get_averageNum()
+  } 
+  .property float64 averageLength()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get float64 assembly::get_averageLength()
+  } 
+  .property class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[]
+          categories6()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::get_categories6()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOn.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOn.il.netcore.release.bsl
new file mode 100644
index 00000000000..925e78803dd
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Aggregates01.fs.RealInternalSignatureOn.il.netcore.release.bsl
@@ -0,0 +1,7081 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern System.Linq
+{
+  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         
+  .ver 8:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 11@12'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_factorsOf300()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 11@12'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname numSum@21
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/numSum@21::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/numSum@21::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/numSum@21::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/numSum@21::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/numSum@21::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/numSum@21::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/numSum@21::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/numSum@21::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/numSum@21::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/numSum@21::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/numSum@21::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/numSum@21::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/numSum@21::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/numSum@21::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/numSum@21::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/numSum@21::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/numSum@21::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/numSum@21::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                              int32,
+                                                                              int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'numSum@22-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'numSum@22-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'numSum@22-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'numSum@22-1' assembly/'numSum@22-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname totalChars@30
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/totalChars@30::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/totalChars@30::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/totalChars@30::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/totalChars@30::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/totalChars@30::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/totalChars@30::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/totalChars@30::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/totalChars@30::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/totalChars@30::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/totalChars@30::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/totalChars@30::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/totalChars@30::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/totalChars@30::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/totalChars@30::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/totalChars@30::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/totalChars@30::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/totalChars@30::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/totalChars@30::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                  int32,
+                                                                                  string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'totalChars@31-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'totalChars@31-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'totalChars@31-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'totalChars@31-1' assembly/'totalChars@31-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@39'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@39'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@39'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@40-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@40-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@40-1' assembly/'Pipe #2 input at line 38@40-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@40-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@40-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@40-2' assembly/'Pipe #2 input at line 38@40-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname sum@42
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/sum@42::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/sum@42::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/sum@42::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/sum@42::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/sum@42::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/sum@42::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/sum@42::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/sum@42::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/sum@42::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/sum@42::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/sum@42::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/sum@42::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/sum@42::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/sum@42::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/sum@42::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/sum@42::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/sum@42::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/sum@42::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/sum@42::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/sum@42::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/sum@42::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                           int32,
+                                                                           class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'sum@43-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>
+  {
+    .field static assembly initonly class assembly/'sum@43-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'sum@43-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'sum@43-1' assembly/'sum@43-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@40-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               int32 V_1,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable> V_4,
+               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32> V_5,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_6,
+               class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> V_7,
+               int32 V_8,
+               int32 V_9,
+               class [runtime]System.IDisposable V_10)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  stloc.2
+      IL_0008:  ldloc.2
+      IL_0009:  stloc.3
+      IL_000a:  ldloc.0
+      IL_000b:  ldnull
+      IL_000c:  ldc.i4.0
+      IL_000d:  ldnull
+      IL_000e:  newobj     instance void assembly/sum@42::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                           int32,
+                                                                           class [Utils]Utils/Product)
+      IL_0013:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0018:  stloc.s    V_4
+      IL_001a:  ldsfld     class assembly/'sum@43-1' assembly/'sum@43-1'::@_instance
+      IL_001f:  stloc.s    V_5
+      IL_0021:  ldloc.s    V_4
+      IL_0023:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_0028:  stloc.s    V_6
+      IL_002a:  ldloc.s    V_6
+      IL_002c:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0031:  stloc.s    V_7
+      .try
+      {
+        IL_0033:  ldc.i4.0
+        IL_0034:  stloc.s    V_9
+        IL_0036:  br.s       IL_004b
+
+        IL_0038:  ldloc.s    V_9
+        IL_003a:  ldloc.s    V_5
+        IL_003c:  ldloc.s    V_7
+        IL_003e:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+        IL_0043:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>::Invoke(!0)
+        IL_0048:  add.ovf
+        IL_0049:  stloc.s    V_9
+        IL_004b:  ldloc.s    V_7
+        IL_004d:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+        IL_0052:  brtrue.s   IL_0038
+
+        IL_0054:  ldloc.s    V_9
+        IL_0056:  stloc.s    V_8
+        IL_0058:  leave.s    IL_0070
+
+      }  
+      finally
+      {
+        IL_005a:  ldloc.s    V_7
+        IL_005c:  isinst     [runtime]System.IDisposable
+        IL_0061:  stloc.s    V_10
+        IL_0063:  ldloc.s    V_10
+        IL_0065:  brfalse.s  IL_006f
+
+        IL_0067:  ldloc.s    V_10
+        IL_0069:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+        IL_006e:  endfinally
+        IL_006f:  endfinally
+      }  
+      IL_0070:  ldloc.s    V_8
+      IL_0072:  stloc.1
+      IL_0073:  ldarg.0
+      IL_0074:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@40-3'::builder@
+      IL_0079:  ldloc.0
+      IL_007a:  ldloc.1
+      IL_007b:  newobj     instance void class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>::.ctor(!0,
+                                                                                                                                                                          !1)
+      IL_0080:  tail.
+      IL_0082:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object>(!!0)
+      IL_0087:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@45-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,class [runtime]System.Tuple`2<string,int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@45-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,class [runtime]System.Tuple`2<string,int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,int32> Invoke(class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               int32 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,int32>::.ctor(!0,
+                                                                                                   !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@45-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@45-4' assembly/'Pipe #2 input at line 38@45-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname minNum@49
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/minNum@49::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/minNum@49::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/minNum@49::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/minNum@49::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/minNum@49::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/minNum@49::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/minNum@49::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/minNum@49::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/minNum@49::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/minNum@49::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/minNum@49::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/minNum@49::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/minNum@49::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/minNum@49::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/minNum@49::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/minNum@49::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/minNum@49::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/minNum@49::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                              int32,
+                                                                              int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'minNum@49-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'minNum@49-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'minNum@49-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'minNum@49-1' assembly/'minNum@49-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname shortestWord@52
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/shortestWord@52::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/shortestWord@52::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/shortestWord@52::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/shortestWord@52::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/shortestWord@52::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/shortestWord@52::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/shortestWord@52::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/shortestWord@52::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/shortestWord@52::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/shortestWord@52::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/shortestWord@52::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/shortestWord@52::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/shortestWord@52::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/shortestWord@52::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/shortestWord@52::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/shortestWord@52::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/shortestWord@52::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/shortestWord@52::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                    int32,
+                                                                                    string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'shortestWord@52-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'shortestWord@52-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'shortestWord@52-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'shortestWord@52-1' assembly/'shortestWord@52-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@57'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 56@57'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 56@57'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@58-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 56@58-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 56@58-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 56@58-1' assembly/'Pipe #3 input at line 56@58-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@58-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 56@58-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 56@58-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 56@58-2' assembly/'Pipe #3 input at line 56@58-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname min@59
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/min@59::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/min@59::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/min@59::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/min@59::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/min@59::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/min@59::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/min@59::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/min@59::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/min@59::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/min@59::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/min@59::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/min@59::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/min@59::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/min@59::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/min@59::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/min@59::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/min@59::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/min@59::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/min@59::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/min@59::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/min@59::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                           int32,
+                                                                           class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'min@59-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'min@59-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'min@59-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'min@59-1' assembly/'min@59-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@58-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 56@58-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  ldloc.0
+      IL_0008:  ldnull
+      IL_0009:  ldc.i4.0
+      IL_000a:  ldnull
+      IL_000b:  newobj     instance void assembly/min@59::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                           int32,
+                                                                           class [Utils]Utils/Product)
+      IL_0010:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0015:  ldsfld     class assembly/'min@59-1' assembly/'min@59-1'::@_instance
+      IL_001a:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MinBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,valuetype [runtime]System.Decimal>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_001f:  stloc.1
+      IL_0020:  ldarg.0
+      IL_0021:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 56@58-3'::builder@
+      IL_0026:  ldloc.0
+      IL_0027:  ldloc.1
+      IL_0028:  newobj     instance void class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                                                                                             !1)
+      IL_002d:  tail.
+      IL_002f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(!!0)
+      IL_0034:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 56@60-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 56@60-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                      !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 56@60-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 56@60-4' assembly/'Pipe #3 input at line 56@60-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@66'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 65@66'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 65@66'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@67-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 65@67-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 65@67-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 65@67-1' assembly/'Pipe #4 input at line 65@67-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@67-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 65@67-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 65@67-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 65@67-2' assembly/'Pipe #4 input at line 65@67-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class abstract auto autochar serializable sealed nested assembly beforefieldinit specialname 'min@68-2'
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method assembly static valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname cheapestProducts@69
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/cheapestProducts@69::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/cheapestProducts@69::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/cheapestProducts@69::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/cheapestProducts@69::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/cheapestProducts@69::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/cheapestProducts@69::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/cheapestProducts@69::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/cheapestProducts@69::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/cheapestProducts@69::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/cheapestProducts@69::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/cheapestProducts@69::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/cheapestProducts@69::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/cheapestProducts@69::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                        class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                        int32,
+                                                                                        class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'cheapestProducts@69-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field public valuetype [runtime]System.Decimal min
+    .method assembly specialname rtspecialname instance void  .ctor(valuetype [runtime]System.Decimal min) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      valuetype [runtime]System.Decimal assembly/'cheapestProducts@69-1'::min
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0006:  ldarg.0
+      IL_0007:  ldfld      valuetype [runtime]System.Decimal assembly/'cheapestProducts@69-1'::min
+      IL_000c:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                         valuetype [netstandard]System.Decimal)
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@67-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 65@67-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_2,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  ldnull
+      IL_0004:  ldftn      valuetype [runtime]System.Decimal assembly/'min@68-2'::Invoke(class [Utils]Utils/Product)
+      IL_000a:  newobj     instance void class [runtime]System.Func`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor(object,
+                                                                                                                                                         native int)
+      IL_000f:  call       valuetype [runtime]System.Decimal [System.Linq]System.Linq.Enumerable::Min<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                                                         class [runtime]System.Func`2<!!0,valuetype [runtime]System.Decimal>)
+      IL_0014:  stloc.1
+      IL_0015:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_001a:  stloc.3
+      IL_001b:  ldloc.3
+      IL_001c:  ldloc.0
+      IL_001d:  ldnull
+      IL_001e:  ldc.i4.0
+      IL_001f:  ldnull
+      IL_0020:  newobj     instance void assembly/cheapestProducts@69::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                        class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                        int32,
+                                                                                        class [Utils]Utils/Product)
+      IL_0025:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_002a:  ldloc.1
+      IL_002b:  newobj     instance void assembly/'cheapestProducts@69-1'::.ctor(valuetype [runtime]System.Decimal)
+      IL_0030:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_003a:  stloc.2
+      IL_003b:  ldarg.0
+      IL_003c:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 65@67-3'::builder@
+      IL_0041:  ldloc.0
+      IL_0042:  ldloc.1
+      IL_0043:  ldloc.2
+      IL_0044:  newobj     instance void class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                                                                                                                                        !1,
+                                                                                                                                                                                                                                                                                                        !2)
+      IL_0049:  tail.
+      IL_004b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(!!0)
+      IL_0050:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 65@70-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 65@70-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> Invoke(class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldarg.1
+      IL_000f:  call       instance !2 class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item3()
+      IL_0014:  stloc.2
+      IL_0015:  ldloc.0
+      IL_0016:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_001b:  ldloc.2
+      IL_001c:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                        !1)
+      IL_0021:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 65@70-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 65@70-4' assembly/'Pipe #4 input at line 65@70-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname maxNum@74
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/maxNum@74::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/maxNum@74::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxNum@74::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/maxNum@74::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/maxNum@74::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/maxNum@74::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/maxNum@74::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/maxNum@74::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/maxNum@74::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxNum@74::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/maxNum@74::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/maxNum@74::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/maxNum@74::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/maxNum@74::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/maxNum@74::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxNum@74::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxNum@74::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/maxNum@74::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                              int32,
+                                                                              int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'maxNum@74-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'maxNum@74-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'maxNum@74-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'maxNum@74-1' assembly/'maxNum@74-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname longestLength@77
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/longestLength@77::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/longestLength@77::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/longestLength@77::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/longestLength@77::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/longestLength@77::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/longestLength@77::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/longestLength@77::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/longestLength@77::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/longestLength@77::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/longestLength@77::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/longestLength@77::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/longestLength@77::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/longestLength@77::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/longestLength@77::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/longestLength@77::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/longestLength@77::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/longestLength@77::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/longestLength@77::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                     int32,
+                                                                                     string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'longestLength@77-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'longestLength@77-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'longestLength@77-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'longestLength@77-1' assembly/'longestLength@77-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@82'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #5 input at line 81@82'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #5 input at line 81@82'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@83-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 81@83-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 81@83-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 81@83-1' assembly/'Pipe #5 input at line 81@83-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@83-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 81@83-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 81@83-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 81@83-2' assembly/'Pipe #5 input at line 81@83-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname mostExpensivePrice@84
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensivePrice@84::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensivePrice@84::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/mostExpensivePrice@84::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/mostExpensivePrice@84::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensivePrice@84::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/mostExpensivePrice@84::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensivePrice@84::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/mostExpensivePrice@84::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensivePrice@84::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/mostExpensivePrice@84::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                          class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                          int32,
+                                                                                          class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'mostExpensivePrice@84-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'mostExpensivePrice@84-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'mostExpensivePrice@84-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'mostExpensivePrice@84-1' assembly/'mostExpensivePrice@84-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@83-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #5 input at line 81@83-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  ldloc.0
+      IL_0008:  ldnull
+      IL_0009:  ldc.i4.0
+      IL_000a:  ldnull
+      IL_000b:  newobj     instance void assembly/mostExpensivePrice@84::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                          class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                          int32,
+                                                                                          class [Utils]Utils/Product)
+      IL_0010:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0015:  ldsfld     class assembly/'mostExpensivePrice@84-1' assembly/'mostExpensivePrice@84-1'::@_instance
+      IL_001a:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MaxBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,valuetype [runtime]System.Decimal>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_001f:  stloc.1
+      IL_0020:  ldarg.0
+      IL_0021:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #5 input at line 81@83-3'::builder@
+      IL_0026:  ldloc.0
+      IL_0027:  ldloc.1
+      IL_0028:  newobj     instance void class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                                                                                             !1)
+      IL_002d:  tail.
+      IL_002f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(!!0)
+      IL_0034:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 81@85-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 81@85-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                      !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 81@85-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 81@85-4' assembly/'Pipe #5 input at line 81@85-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@91'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 90@91'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 90@91'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@92-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 90@92-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 90@92-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 90@92-1' assembly/'Pipe #6 input at line 90@92-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@92-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 90@92-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 90@92-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 90@92-2' assembly/'Pipe #6 input at line 90@92-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname maxPrice@93
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/maxPrice@93::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/maxPrice@93::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxPrice@93::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/maxPrice@93::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/maxPrice@93::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/maxPrice@93::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/maxPrice@93::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/maxPrice@93::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxPrice@93::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/maxPrice@93::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/maxPrice@93::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/maxPrice@93::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/maxPrice@93::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/maxPrice@93::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/maxPrice@93::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/maxPrice@93::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/maxPrice@93::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                int32,
+                                                                                class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'maxPrice@93-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'maxPrice@93-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'maxPrice@93-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'maxPrice@93-1' assembly/'maxPrice@93-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname mostExpensiveProducts@94
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/mostExpensiveProducts@94::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/mostExpensiveProducts@94::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/mostExpensiveProducts@94::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/mostExpensiveProducts@94::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/mostExpensiveProducts@94::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/mostExpensiveProducts@94::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                             class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                             int32,
+                                                                                             class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'mostExpensiveProducts@94-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field public valuetype [runtime]System.Decimal maxPrice
+    .method assembly specialname rtspecialname instance void  .ctor(valuetype [runtime]System.Decimal maxPrice) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      valuetype [runtime]System.Decimal assembly/'mostExpensiveProducts@94-1'::maxPrice
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0006:  ldarg.0
+      IL_0007:  ldfld      valuetype [runtime]System.Decimal assembly/'mostExpensiveProducts@94-1'::maxPrice
+      IL_000c:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                         valuetype [netstandard]System.Decimal)
+      IL_0011:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@92-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 90@92-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_2,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  ldloc.0
+      IL_0008:  ldnull
+      IL_0009:  ldc.i4.0
+      IL_000a:  ldnull
+      IL_000b:  newobj     instance void assembly/maxPrice@93::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                int32,
+                                                                                class [Utils]Utils/Product)
+      IL_0010:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0015:  ldsfld     class assembly/'maxPrice@93-1' assembly/'maxPrice@93-1'::@_instance
+      IL_001a:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MaxBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,valuetype [runtime]System.Decimal>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_001f:  stloc.1
+      IL_0020:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0025:  stloc.3
+      IL_0026:  ldloc.3
+      IL_0027:  ldloc.0
+      IL_0028:  ldnull
+      IL_0029:  ldc.i4.0
+      IL_002a:  ldnull
+      IL_002b:  newobj     instance void assembly/mostExpensiveProducts@94::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                             class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                             int32,
+                                                                                             class [Utils]Utils/Product)
+      IL_0030:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0035:  ldloc.1
+      IL_0036:  newobj     instance void assembly/'mostExpensiveProducts@94-1'::.ctor(valuetype [runtime]System.Decimal)
+      IL_003b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+      IL_0040:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_0045:  stloc.2
+      IL_0046:  ldarg.0
+      IL_0047:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 90@92-3'::builder@
+      IL_004c:  ldloc.0
+      IL_004d:  ldloc.1
+      IL_004e:  ldloc.2
+      IL_004f:  newobj     instance void class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                                                                                                                                        !1,
+                                                                                                                                                                                                                                                                                                        !2)
+      IL_0054:  tail.
+      IL_0056:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(!!0)
+      IL_005b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 90@95-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 90@95-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> Invoke(class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldarg.1
+      IL_000f:  call       instance !2 class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item3()
+      IL_0014:  stloc.2
+      IL_0015:  ldloc.0
+      IL_0016:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_001b:  ldloc.2
+      IL_001c:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                        !1)
+      IL_0021:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 90@95-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 90@95-4' assembly/'Pipe #6 input at line 90@95-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname averageNum@100
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<float64>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<float64> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public float64 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<float64> 'enum',
+                                 int32 pc,
+                                 float64 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/averageNum@100::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      float64 assembly/averageNum@100::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<float64>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<float64>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (float64 V_0,
+               float64 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averageNum@100::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> assembly::get_numbers2()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<float64>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/averageNum@100::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<float64>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/averageNum@100::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      float64 assembly/averageNum@100::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/averageNum@100::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<float64>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/averageNum@100::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.r8     0.0
+      IL_0095:  stfld      float64 assembly/averageNum@100::current
+      IL_009a:  ldc.i4.0
+      IL_009b:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averageNum@100::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_007e
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/averageNum@100::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/averageNum@100::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<float64> assembly/averageNum@100::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<float64>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/averageNum@100::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.r8     0.0
+        IL_0067:  stfld      float64 assembly/averageNum@100::current
+        IL_006c:  leave.s    IL_0078
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_006e:  castclass  [runtime]System.Exception
+        IL_0073:  stloc.1
+        IL_0074:  ldloc.1
+        IL_0075:  stloc.0
+        IL_0076:  leave.s    IL_0078
+
+      }  
+      IL_0078:  nop
+      IL_0079:  br         IL_0000
+
+      IL_007e:  ldloc.0
+      IL_007f:  brfalse.s  IL_0083
+
+      IL_0081:  ldloc.0
+      IL_0082:  throw
+
+      IL_0083:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averageNum@100::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance float64 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      float64 assembly/averageNum@100::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<float64> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.r8     0.0
+      IL_000b:  newobj     instance void assembly/averageNum@100::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<float64>,
+                                                                                   int32,
+                                                                                   float64)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'averageNum@100-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,float64>
+  {
+    .field static assembly initonly class assembly/'averageNum@100-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,float64>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance float64 Invoke(float64 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'averageNum@100-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'averageNum@100-1' assembly/'averageNum@100-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit averageLength@105
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/averageLength@105::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,object> Invoke(string _arg1) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (string V_0,
+               float64 V_1,
+               int32 V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0008:  stloc.2
+      IL_0009:  ldloc.2
+      IL_000a:  conv.r8
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/averageLength@105::builder@
+      IL_0012:  ldloc.0
+      IL_0013:  ldloc.1
+      IL_0014:  newobj     instance void class [runtime]System.Tuple`2<string,float64>::.ctor(!0,
+                                                                                                     !1)
+      IL_0019:  tail.
+      IL_001b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<string,float64>,object>(!!0)
+      IL_0020:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'averageLength@107-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,float64>,float64>
+  {
+    .field static assembly initonly class assembly/'averageLength@107-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,float64>,float64>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance float64 Invoke(class [runtime]System.Tuple`2<string,float64> tupledArg) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (string V_0,
+               float64 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<string,float64>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<string,float64>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'averageLength@107-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'averageLength@107-1' assembly/'averageLength@107-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@113'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 112@113'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 112@113'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@114-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 112@114-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 112@114-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 112@114-1' assembly/'Pipe #7 input at line 112@114-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@114-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 112@114-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 112@114-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 112@114-2' assembly/'Pipe #7 input at line 112@114-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname averagePrice@115
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g,
+                                 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/averagePrice@115::g
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/averagePrice@115::pc
+      IL_0015:  ldarg.0
+      IL_0016:  ldarg.s    current
+      IL_0018:  stfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+      IL_001d:  ldarg.0
+      IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_0023:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averagePrice@115::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008c
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/averagePrice@115::g
+      IL_002d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0032:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0037:  ldarg.0
+      IL_0038:  ldc.i4.1
+      IL_0039:  stfld      int32 assembly/averagePrice@115::pc
+      IL_003e:  br.s       IL_005e
+
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0046:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004b:  stloc.0
+      IL_004c:  ldloc.0
+      IL_004d:  stloc.1
+      IL_004e:  ldarg.0
+      IL_004f:  ldc.i4.2
+      IL_0050:  stfld      int32 assembly/averagePrice@115::pc
+      IL_0055:  ldarg.0
+      IL_0056:  ldloc.1
+      IL_0057:  stfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+      IL_005c:  ldc.i4.1
+      IL_005d:  ret
+
+      IL_005e:  ldarg.0
+      IL_005f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0064:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0069:  brtrue.s   IL_0040
+
+      IL_006b:  ldarg.0
+      IL_006c:  ldc.i4.3
+      IL_006d:  stfld      int32 assembly/averagePrice@115::pc
+      IL_0072:  ldarg.0
+      IL_0073:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0078:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007d:  nop
+      IL_007e:  ldarg.0
+      IL_007f:  ldnull
+      IL_0080:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+      IL_0085:  ldarg.0
+      IL_0086:  ldc.i4.3
+      IL_0087:  stfld      int32 assembly/averagePrice@115::pc
+      IL_008c:  ldarg.0
+      IL_008d:  ldnull
+      IL_008e:  stfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+      IL_0093:  ldc.i4.0
+      IL_0094:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averagePrice@115::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/averagePrice@115::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/averagePrice@115::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/averagePrice@115::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/averagePrice@115::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/averagePrice@115::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/averagePrice@115::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> assembly/averagePrice@115::g
+      IL_0006:  ldnull
+      IL_0007:  ldc.i4.0
+      IL_0008:  ldnull
+      IL_0009:  newobj     instance void assembly/averagePrice@115::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                     class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                     int32,
+                                                                                     class [Utils]Utils/Product)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'averagePrice@115-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'averagePrice@115-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'averagePrice@115-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'averagePrice@115-1' assembly/'averagePrice@115-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@114-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 112@114-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable> V_4,
+               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal> V_5,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_6,
+               class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> V_7,
+               valuetype [runtime]System.Decimal V_8,
+               valuetype [runtime]System.Decimal V_9,
+               int32 V_10,
+               valuetype [runtime]System.Decimal V_11,
+               int32 V_12,
+               class [runtime]System.IDisposable V_13)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  stloc.2
+      IL_0008:  ldloc.2
+      IL_0009:  stloc.3
+      IL_000a:  ldloc.0
+      IL_000b:  ldnull
+      IL_000c:  ldc.i4.0
+      IL_000d:  ldnull
+      IL_000e:  newobj     instance void assembly/averagePrice@115::.ctor(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,
+                                                                                     class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                     int32,
+                                                                                     class [Utils]Utils/Product)
+      IL_0013:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+      IL_0018:  stloc.s    V_4
+      IL_001a:  ldsfld     class assembly/'averagePrice@115-1' assembly/'averagePrice@115-1'::@_instance
+      IL_001f:  stloc.s    V_5
+      IL_0021:  ldloc.s    V_4
+      IL_0023:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_0028:  stloc.s    V_6
+      IL_002a:  ldloc.s    V_6
+      IL_002c:  box        class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>
+      IL_0031:  brtrue.s   IL_003e
+
+      IL_0033:  ldstr      "source"
+      IL_0038:  newobj     instance void [netstandard]System.ArgumentNullException::.ctor(string)
+      IL_003d:  throw
+
+      IL_003e:  nop
+      IL_003f:  ldloc.s    V_6
+      IL_0041:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0046:  stloc.s    V_7
+      .try
+      {
+        IL_0048:  ldc.i4.0
+        IL_0049:  ldc.i4.0
+        IL_004a:  ldc.i4.0
+        IL_004b:  ldc.i4.0
+        IL_004c:  ldc.i4.0
+        IL_004d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                              int32,
+                                                                              int32,
+                                                                              bool,
+                                                                              uint8)
+        IL_0052:  stloc.s    V_9
+        IL_0054:  ldc.i4.0
+        IL_0055:  stloc.s    V_10
+        IL_0057:  br.s       IL_0076
+
+        IL_0059:  ldloc.s    V_9
+        IL_005b:  ldloc.s    V_5
+        IL_005d:  ldloc.s    V_7
+        IL_005f:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+        IL_0064:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::Invoke(!0)
+        IL_0069:  call       valuetype [netstandard]System.Decimal [netstandard]System.Decimal::op_Addition(valuetype [netstandard]System.Decimal,
+                                                                                                            valuetype [netstandard]System.Decimal)
+        IL_006e:  stloc.s    V_9
+        IL_0070:  ldloc.s    V_10
+        IL_0072:  ldc.i4.1
+        IL_0073:  add
+        IL_0074:  stloc.s    V_10
+        IL_0076:  ldloc.s    V_7
+        IL_0078:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+        IL_007d:  brtrue.s   IL_0059
+
+        IL_007f:  ldloc.s    V_10
+        IL_0081:  brtrue.s   IL_008e
+
+        IL_0083:  ldstr      "source"
+        IL_0088:  newobj     instance void [netstandard]System.InvalidOperationException::.ctor(string)
+        IL_008d:  throw
+
+        IL_008e:  nop
+        IL_008f:  ldloc.s    V_9
+        IL_0091:  stloc.s    V_11
+        IL_0093:  ldloc.s    V_10
+        IL_0095:  stloc.s    V_12
+        IL_0097:  ldloc.s    V_11
+        IL_0099:  ldloc.s    V_12
+        IL_009b:  call       valuetype [netstandard]System.Decimal [netstandard]System.Convert::ToDecimal(int32)
+        IL_00a0:  call       valuetype [netstandard]System.Decimal [netstandard]System.Decimal::Divide(valuetype [netstandard]System.Decimal,
+                                                                                                       valuetype [netstandard]System.Decimal)
+        IL_00a5:  stloc.s    V_8
+        IL_00a7:  leave.s    IL_00bf
+
+      }  
+      finally
+      {
+        IL_00a9:  ldloc.s    V_7
+        IL_00ab:  isinst     [runtime]System.IDisposable
+        IL_00b0:  stloc.s    V_13
+        IL_00b2:  ldloc.s    V_13
+        IL_00b4:  brfalse.s  IL_00be
+
+        IL_00b6:  ldloc.s    V_13
+        IL_00b8:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+        IL_00bd:  endfinally
+        IL_00be:  endfinally
+      }  
+      IL_00bf:  ldloc.s    V_8
+      IL_00c1:  stloc.1
+      IL_00c2:  ldarg.0
+      IL_00c3:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 112@114-3'::builder@
+      IL_00c8:  ldloc.0
+      IL_00c9:  ldloc.1
+      IL_00ca:  newobj     instance void class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                                                                                             !1)
+      IL_00cf:  tail.
+      IL_00d1:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(!!0)
+      IL_00d6:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 112@116-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 112@116-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0,
+               valuetype [runtime]System.Decimal V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                      !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 112@116-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 112@116-4' assembly/'Pipe #7 input at line 112@116-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> factorsOf300@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 uniqueFactors@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 numSum@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@26
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 totalChars@28
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@35
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,int32>[] categories@37
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 minNum@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 shortestWord@52
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] categories2@55
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] categories3@64
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 maxNum@74
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 longestLength@77
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] categories4@80
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] categories5@89
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> numbers2@99
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly float64 averageNum@100
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly float64 averageLength@103
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] categories6@111
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_factorsOf300() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::factorsOf300@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_uniqueFactors() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::uniqueFactors@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@17
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_numSum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::numSum@19
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@26
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_totalChars() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::totalChars@28
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@35
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,int32>[] get_categories() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,int32>[] assembly::categories@37
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_minNum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::minNum@49
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_shortestWord() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::shortestWord@52
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] get_categories2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories2@55
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] get_categories3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::categories3@64
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_maxNum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::maxNum@74
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_longestLength() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::longestLength@77
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] get_categories4() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories4@80
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] get_categories5() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::categories5@89
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> get_numbers2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> assembly::numbers2@99
+    IL_0005:  ret
+  } 
+
+  .method public specialname static float64 get_averageNum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     float64 assembly::averageNum@100
+    IL_0005:  ret
+  } 
+
+  .method public specialname static float64 get_averageLength() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     float64 assembly::averageLength@103
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] get_categories6() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories6@111
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32> V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_6,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_7,
+             int32 V_8,
+             int32 V_9,
+             class [runtime]System.IDisposable V_10,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_11,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_12,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable> V_13,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32> V_14,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_15,
+             class [runtime]System.Collections.Generic.IEnumerator`1<string> V_16,
+             int32 V_17,
+             int32 V_18,
+             class [runtime]System.IDisposable V_19,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> V_20,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_21,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>> V_22,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_23,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>> V_24,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_25,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>> V_26,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_27,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>> V_28,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_29,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_30,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_31,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<float64,class [runtime]System.Collections.IEnumerable> V_32,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,float64> V_33,
+             class [runtime]System.Collections.Generic.IEnumerable`1<float64> V_34,
+             class [runtime]System.Collections.Generic.IEnumerator`1<float64> V_35,
+             float64 V_36,
+             float64 V_37,
+             int32 V_38,
+             float64 V_39,
+             int32 V_40,
+             class [runtime]System.IDisposable V_41,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_42,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_43,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,class [runtime]System.Collections.IEnumerable> V_44,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,float64>,float64> V_45,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,float64>> V_46,
+             class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<string,float64>> V_47,
+             float64 V_48,
+             float64 V_49,
+             int32 V_50,
+             float64 V_51,
+             int32 V_52,
+             class [runtime]System.IDisposable V_53,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>> V_54,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_55)
+    IL_0000:  ldc.i4.2
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  ldc.i4.5
+    IL_0004:  ldc.i4.5
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::factorsOf300@8
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_002d:  stloc.1
+    IL_002e:  ldloc.1
+    IL_002f:  ldnull
+    IL_0030:  ldc.i4.0
+    IL_0031:  ldc.i4.0
+    IL_0032:  newobj     instance void assembly/'Pipe #1 input at line 11@12'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                int32,
+                                                                                                int32)
+    IL_0037:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_003c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Distinct<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_0041:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0046:  stloc.0
+    IL_0047:  ldloc.0
+    IL_0048:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_004d:  stsfld     int32 assembly::uniqueFactors@10
+    IL_0052:  ldc.i4.5
+    IL_0053:  ldc.i4.4
+    IL_0054:  ldc.i4.1
+    IL_0055:  ldc.i4.3
+    IL_0056:  ldc.i4.s   9
+    IL_0058:  ldc.i4.8
+    IL_0059:  ldc.i4.6
+    IL_005a:  ldc.i4.7
+    IL_005b:  ldc.i4.2
+    IL_005c:  ldc.i4.0
+    IL_005d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0062:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0067:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_006c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0071:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0076:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_007b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0080:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0085:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_008a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_008f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0094:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@17
+    IL_0099:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_009e:  stloc.2
+    IL_009f:  ldloc.2
+    IL_00a0:  stloc.3
+    IL_00a1:  ldnull
+    IL_00a2:  ldc.i4.0
+    IL_00a3:  ldc.i4.0
+    IL_00a4:  newobj     instance void assembly/numSum@21::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                            int32,
+                                                                            int32)
+    IL_00a9:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00ae:  stloc.s    V_4
+    IL_00b0:  ldsfld     class assembly/'numSum@22-1' assembly/'numSum@22-1'::@_instance
+    IL_00b5:  stloc.s    V_5
+    IL_00b7:  ldloc.s    V_4
+    IL_00b9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00be:  stloc.s    V_6
+    IL_00c0:  ldloc.s    V_6
+    IL_00c2:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_00c7:  stloc.s    V_7
+    .try
+    {
+      IL_00c9:  ldc.i4.0
+      IL_00ca:  stloc.s    V_9
+      IL_00cc:  br.s       IL_00e1
+
+      IL_00ce:  ldloc.s    V_9
+      IL_00d0:  ldloc.s    V_5
+      IL_00d2:  ldloc.s    V_7
+      IL_00d4:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_00d9:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::Invoke(!0)
+      IL_00de:  add.ovf
+      IL_00df:  stloc.s    V_9
+      IL_00e1:  ldloc.s    V_7
+      IL_00e3:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+      IL_00e8:  brtrue.s   IL_00ce
+
+      IL_00ea:  ldloc.s    V_9
+      IL_00ec:  stloc.s    V_8
+      IL_00ee:  leave.s    IL_0106
+
+    }  
+    finally
+    {
+      IL_00f0:  ldloc.s    V_7
+      IL_00f2:  isinst     [runtime]System.IDisposable
+      IL_00f7:  stloc.s    V_10
+      IL_00f9:  ldloc.s    V_10
+      IL_00fb:  brfalse.s  IL_0105
+
+      IL_00fd:  ldloc.s    V_10
+      IL_00ff:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+      IL_0104:  endfinally
+      IL_0105:  endfinally
+    }  
+    IL_0106:  ldloc.s    V_8
+    IL_0108:  stsfld     int32 assembly::numSum@19
+    IL_010d:  ldstr      "cherry"
+    IL_0112:  ldstr      "apple"
+    IL_0117:  ldstr      "blueberry"
+    IL_011c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0121:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0126:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_012b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0130:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@26
+    IL_0135:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_013a:  stloc.s    V_11
+    IL_013c:  ldloc.s    V_11
+    IL_013e:  stloc.s    V_12
+    IL_0140:  ldnull
+    IL_0141:  ldc.i4.0
+    IL_0142:  ldnull
+    IL_0143:  newobj     instance void assembly/totalChars@30::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                int32,
+                                                                                string)
+    IL_0148:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_014d:  stloc.s    V_13
+    IL_014f:  ldsfld     class assembly/'totalChars@31-1' assembly/'totalChars@31-1'::@_instance
+    IL_0154:  stloc.s    V_14
+    IL_0156:  ldloc.s    V_13
+    IL_0158:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_015d:  stloc.s    V_15
+    IL_015f:  ldloc.s    V_15
+    IL_0161:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+    IL_0166:  stloc.s    V_16
+    .try
+    {
+      IL_0168:  ldc.i4.0
+      IL_0169:  stloc.s    V_18
+      IL_016b:  br.s       IL_0180
+
+      IL_016d:  ldloc.s    V_18
+      IL_016f:  ldloc.s    V_14
+      IL_0171:  ldloc.s    V_16
+      IL_0173:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_0178:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::Invoke(!0)
+      IL_017d:  add.ovf
+      IL_017e:  stloc.s    V_18
+      IL_0180:  ldloc.s    V_16
+      IL_0182:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+      IL_0187:  brtrue.s   IL_016d
+
+      IL_0189:  ldloc.s    V_18
+      IL_018b:  stloc.s    V_17
+      IL_018d:  leave.s    IL_01a5
+
+    }  
+    finally
+    {
+      IL_018f:  ldloc.s    V_16
+      IL_0191:  isinst     [runtime]System.IDisposable
+      IL_0196:  stloc.s    V_19
+      IL_0198:  ldloc.s    V_19
+      IL_019a:  brfalse.s  IL_01a4
+
+      IL_019c:  ldloc.s    V_19
+      IL_019e:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+      IL_01a3:  endfinally
+      IL_01a4:  endfinally
+    }  
+    IL_01a5:  ldloc.s    V_17
+    IL_01a7:  stsfld     int32 assembly::totalChars@28
+    IL_01ac:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_01b1:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@35
+    IL_01b6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_01bb:  stloc.s    V_21
+    IL_01bd:  ldloc.s    V_21
+    IL_01bf:  ldloc.s    V_21
+    IL_01c1:  ldloc.s    V_21
+    IL_01c3:  ldloc.s    V_21
+    IL_01c5:  ldloc.s    V_21
+    IL_01c7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_01cc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01d1:  ldloc.s    V_21
+    IL_01d3:  newobj     instance void assembly/'Pipe #2 input at line 38@39'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01dd:  ldsfld     class assembly/'Pipe #2 input at line 38@40-1' assembly/'Pipe #2 input at line 38@40-1'::@_instance
+    IL_01e2:  ldsfld     class assembly/'Pipe #2 input at line 38@40-2' assembly/'Pipe #2 input at line 38@40-2'::@_instance
+    IL_01e7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_01ec:  ldloc.s    V_21
+    IL_01ee:  newobj     instance void assembly/'Pipe #2 input at line 38@40-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01f3:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01f8:  ldsfld     class assembly/'Pipe #2 input at line 38@45-4' assembly/'Pipe #2 input at line 38@45-4'::@_instance
+    IL_01fd:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,int32>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,int32>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0202:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,int32>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0207:  stloc.s    V_20
+    IL_0209:  ldloc.s    V_20
+    IL_020b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,int32>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0210:  stsfld     class [runtime]System.Tuple`2<string,int32>[] assembly::categories@37
+    IL_0215:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_021a:  ldnull
+    IL_021b:  ldc.i4.0
+    IL_021c:  ldc.i4.0
+    IL_021d:  newobj     instance void assembly/minNum@49::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                            int32,
+                                                                            int32)
+    IL_0222:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0227:  ldsfld     class assembly/'minNum@49-1' assembly/'minNum@49-1'::@_instance
+    IL_022c:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MinBy<int32,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0231:  stsfld     int32 assembly::minNum@49
+    IL_0236:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_023b:  ldnull
+    IL_023c:  ldc.i4.0
+    IL_023d:  ldnull
+    IL_023e:  newobj     instance void assembly/shortestWord@52::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                  int32,
+                                                                                  string)
+    IL_0243:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0248:  ldsfld     class assembly/'shortestWord@52-1' assembly/'shortestWord@52-1'::@_instance
+    IL_024d:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MinBy<string,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0252:  stsfld     int32 assembly::shortestWord@52
+    IL_0257:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_025c:  stloc.s    V_23
+    IL_025e:  ldloc.s    V_23
+    IL_0260:  ldloc.s    V_23
+    IL_0262:  ldloc.s    V_23
+    IL_0264:  ldloc.s    V_23
+    IL_0266:  ldloc.s    V_23
+    IL_0268:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_026d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0272:  ldloc.s    V_23
+    IL_0274:  newobj     instance void assembly/'Pipe #3 input at line 56@57'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0279:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_027e:  ldsfld     class assembly/'Pipe #3 input at line 56@58-1' assembly/'Pipe #3 input at line 56@58-1'::@_instance
+    IL_0283:  ldsfld     class assembly/'Pipe #3 input at line 56@58-2' assembly/'Pipe #3 input at line 56@58-2'::@_instance
+    IL_0288:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_028d:  ldloc.s    V_23
+    IL_028f:  newobj     instance void assembly/'Pipe #3 input at line 56@58-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0294:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0299:  ldsfld     class assembly/'Pipe #3 input at line 56@60-4' assembly/'Pipe #3 input at line 56@60-4'::@_instance
+    IL_029e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_02a3:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_02a8:  stloc.s    V_22
+    IL_02aa:  ldloc.s    V_22
+    IL_02ac:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_02b1:  stsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories2@55
+    IL_02b6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_02bb:  stloc.s    V_25
+    IL_02bd:  ldloc.s    V_25
+    IL_02bf:  ldloc.s    V_25
+    IL_02c1:  ldloc.s    V_25
+    IL_02c3:  ldloc.s    V_25
+    IL_02c5:  ldloc.s    V_25
+    IL_02c7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_02cc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_02d1:  ldloc.s    V_25
+    IL_02d3:  newobj     instance void assembly/'Pipe #4 input at line 65@66'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_02d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_02dd:  ldsfld     class assembly/'Pipe #4 input at line 65@67-1' assembly/'Pipe #4 input at line 65@67-1'::@_instance
+    IL_02e2:  ldsfld     class assembly/'Pipe #4 input at line 65@67-2' assembly/'Pipe #4 input at line 65@67-2'::@_instance
+    IL_02e7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_02ec:  ldloc.s    V_25
+    IL_02ee:  newobj     instance void assembly/'Pipe #4 input at line 65@67-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_02f3:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_02f8:  ldsfld     class assembly/'Pipe #4 input at line 65@70-4' assembly/'Pipe #4 input at line 65@70-4'::@_instance
+    IL_02fd:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0302:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0307:  stloc.s    V_24
+    IL_0309:  ldloc.s    V_24
+    IL_030b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0310:  stsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::categories3@64
+    IL_0315:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_031a:  ldnull
+    IL_031b:  ldc.i4.0
+    IL_031c:  ldc.i4.0
+    IL_031d:  newobj     instance void assembly/maxNum@74::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                            int32,
+                                                                            int32)
+    IL_0322:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0327:  ldsfld     class assembly/'maxNum@74-1' assembly/'maxNum@74-1'::@_instance
+    IL_032c:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MaxBy<int32,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0331:  stsfld     int32 assembly::maxNum@74
+    IL_0336:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_033b:  ldnull
+    IL_033c:  ldc.i4.0
+    IL_033d:  ldnull
+    IL_033e:  newobj     instance void assembly/longestLength@77::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                   int32,
+                                                                                   string)
+    IL_0343:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0348:  ldsfld     class assembly/'longestLength@77-1' assembly/'longestLength@77-1'::@_instance
+    IL_034d:  callvirt   instance !!2 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::MaxBy<string,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0352:  stsfld     int32 assembly::longestLength@77
+    IL_0357:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_035c:  stloc.s    V_27
+    IL_035e:  ldloc.s    V_27
+    IL_0360:  ldloc.s    V_27
+    IL_0362:  ldloc.s    V_27
+    IL_0364:  ldloc.s    V_27
+    IL_0366:  ldloc.s    V_27
+    IL_0368:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_036d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0372:  ldloc.s    V_27
+    IL_0374:  newobj     instance void assembly/'Pipe #5 input at line 81@82'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0379:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_037e:  ldsfld     class assembly/'Pipe #5 input at line 81@83-1' assembly/'Pipe #5 input at line 81@83-1'::@_instance
+    IL_0383:  ldsfld     class assembly/'Pipe #5 input at line 81@83-2' assembly/'Pipe #5 input at line 81@83-2'::@_instance
+    IL_0388:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_038d:  ldloc.s    V_27
+    IL_038f:  newobj     instance void assembly/'Pipe #5 input at line 81@83-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0394:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0399:  ldsfld     class assembly/'Pipe #5 input at line 81@85-4' assembly/'Pipe #5 input at line 81@85-4'::@_instance
+    IL_039e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_03a3:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_03a8:  stloc.s    V_26
+    IL_03aa:  ldloc.s    V_26
+    IL_03ac:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_03b1:  stsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories4@80
+    IL_03b6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_03bb:  stloc.s    V_29
+    IL_03bd:  ldloc.s    V_29
+    IL_03bf:  ldloc.s    V_29
+    IL_03c1:  ldloc.s    V_29
+    IL_03c3:  ldloc.s    V_29
+    IL_03c5:  ldloc.s    V_29
+    IL_03c7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_03cc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_03d1:  ldloc.s    V_29
+    IL_03d3:  newobj     instance void assembly/'Pipe #6 input at line 90@91'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_03d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_03dd:  ldsfld     class assembly/'Pipe #6 input at line 90@92-1' assembly/'Pipe #6 input at line 90@92-1'::@_instance
+    IL_03e2:  ldsfld     class assembly/'Pipe #6 input at line 90@92-2' assembly/'Pipe #6 input at line 90@92-2'::@_instance
+    IL_03e7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_03ec:  ldloc.s    V_29
+    IL_03ee:  newobj     instance void assembly/'Pipe #6 input at line 90@92-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_03f3:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_03f8:  ldsfld     class assembly/'Pipe #6 input at line 90@95-4' assembly/'Pipe #6 input at line 90@95-4'::@_instance
+    IL_03fd:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`3<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0402:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0407:  stloc.s    V_28
+    IL_0409:  ldloc.s    V_28
+    IL_040b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0410:  stsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::categories5@89
+    IL_0415:  ldc.r8     5.0999999999999996
+    IL_041e:  ldc.r8     4.0999999999999996
+    IL_0427:  ldc.r8     1.1000000000000001
+    IL_0430:  ldc.r8     3.1000000000000001
+    IL_0439:  ldc.r8     9.0999999999999996
+    IL_0442:  ldc.r8     8.0999999999999996
+    IL_044b:  ldc.r8     6.0999999999999996
+    IL_0454:  ldc.r8     7.0999999999999996
+    IL_045d:  ldc.r8     2.1000000000000001
+    IL_0466:  ldc.r8     0.10000000000000001
+    IL_046f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::get_Empty()
+    IL_0474:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0479:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_047e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0483:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0488:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_048d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0492:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0497:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_049c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_04a1:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_04a6:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> assembly::numbers2@99
+    IL_04ab:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_04b0:  stloc.s    V_30
+    IL_04b2:  ldloc.s    V_30
+    IL_04b4:  stloc.s    V_31
+    IL_04b6:  ldnull
+    IL_04b7:  ldc.i4.0
+    IL_04b8:  ldc.r8     0.0
+    IL_04c1:  newobj     instance void assembly/averageNum@100::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<float64>,
+                                                                                 int32,
+                                                                                 float64)
+    IL_04c6:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<float64,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_04cb:  stloc.s    V_32
+    IL_04cd:  ldsfld     class assembly/'averageNum@100-1' assembly/'averageNum@100-1'::@_instance
+    IL_04d2:  stloc.s    V_33
+    IL_04d4:  ldloc.s    V_32
+    IL_04d6:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<float64,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_04db:  stloc.s    V_34
+    IL_04dd:  ldloc.s    V_34
+    IL_04df:  box        class [runtime]System.Collections.Generic.IEnumerable`1<float64>
+    IL_04e4:  brtrue.s   IL_04f1
+
+    IL_04e6:  ldstr      "source"
+    IL_04eb:  newobj     instance void [netstandard]System.ArgumentNullException::.ctor(string)
+    IL_04f0:  throw
+
+    IL_04f1:  nop
+    IL_04f2:  ldloc.s    V_34
+    IL_04f4:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<float64>::GetEnumerator()
+    IL_04f9:  stloc.s    V_35
+    .try
+    {
+      IL_04fb:  ldc.r8     0.0
+      IL_0504:  stloc.s    V_37
+      IL_0506:  ldc.i4.0
+      IL_0507:  stloc.s    V_38
+      IL_0509:  br.s       IL_0524
+
+      IL_050b:  ldloc.s    V_37
+      IL_050d:  ldloc.s    V_33
+      IL_050f:  ldloc.s    V_35
+      IL_0511:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<float64>::get_Current()
+      IL_0516:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,float64>::Invoke(!0)
+      IL_051b:  add
+      IL_051c:  stloc.s    V_37
+      IL_051e:  ldloc.s    V_38
+      IL_0520:  ldc.i4.1
+      IL_0521:  add
+      IL_0522:  stloc.s    V_38
+      IL_0524:  ldloc.s    V_35
+      IL_0526:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+      IL_052b:  brtrue.s   IL_050b
+
+      IL_052d:  ldloc.s    V_38
+      IL_052f:  brtrue.s   IL_053c
+
+      IL_0531:  ldstr      "source"
+      IL_0536:  newobj     instance void [netstandard]System.InvalidOperationException::.ctor(string)
+      IL_053b:  throw
+
+      IL_053c:  nop
+      IL_053d:  ldloc.s    V_37
+      IL_053f:  stloc.s    V_39
+      IL_0541:  ldloc.s    V_38
+      IL_0543:  stloc.s    V_40
+      IL_0545:  ldloc.s    V_39
+      IL_0547:  ldloc.s    V_40
+      IL_0549:  conv.r8
+      IL_054a:  div
+      IL_054b:  stloc.s    V_36
+      IL_054d:  leave.s    IL_0565
+
+    }  
+    finally
+    {
+      IL_054f:  ldloc.s    V_35
+      IL_0551:  isinst     [runtime]System.IDisposable
+      IL_0556:  stloc.s    V_41
+      IL_0558:  ldloc.s    V_41
+      IL_055a:  brfalse.s  IL_0564
+
+      IL_055c:  ldloc.s    V_41
+      IL_055e:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+      IL_0563:  endfinally
+      IL_0564:  endfinally
+    }  
+    IL_0565:  ldloc.s    V_36
+    IL_0567:  stsfld     float64 assembly::averageNum@100
+    IL_056c:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0571:  stloc.s    V_42
+    IL_0573:  ldloc.s    V_42
+    IL_0575:  stloc.s    V_43
+    IL_0577:  ldloc.s    V_42
+    IL_0579:  ldloc.s    V_42
+    IL_057b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+    IL_0580:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0585:  ldloc.s    V_42
+    IL_0587:  newobj     instance void assembly/averageLength@105::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_058c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<string,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,float64>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0591:  stloc.s    V_44
+    IL_0593:  ldsfld     class assembly/'averageLength@107-1' assembly/'averageLength@107-1'::@_instance
+    IL_0598:  stloc.s    V_45
+    IL_059a:  ldloc.s    V_44
+    IL_059c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,float64>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_05a1:  stloc.s    V_46
+    IL_05a3:  ldloc.s    V_46
+    IL_05a5:  box        class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,float64>>
+    IL_05aa:  brtrue.s   IL_05b7
+
+    IL_05ac:  ldstr      "source"
+    IL_05b1:  newobj     instance void [netstandard]System.ArgumentNullException::.ctor(string)
+    IL_05b6:  throw
+
+    IL_05b7:  nop
+    IL_05b8:  ldloc.s    V_46
+    IL_05ba:  callvirt   instance class [netstandard]System.Collections.Generic.IEnumerator`1<!0> class [netstandard]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,float64>>::GetEnumerator()
+    IL_05bf:  stloc.s    V_47
+    .try
+    {
+      IL_05c1:  ldc.r8     0.0
+      IL_05ca:  stloc.s    V_49
+      IL_05cc:  ldc.i4.0
+      IL_05cd:  stloc.s    V_50
+      IL_05cf:  br.s       IL_05ea
+
+      IL_05d1:  ldloc.s    V_49
+      IL_05d3:  ldloc.s    V_45
+      IL_05d5:  ldloc.s    V_47
+      IL_05d7:  callvirt   instance !0 class [netstandard]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<string,float64>>::get_Current()
+      IL_05dc:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,float64>,float64>::Invoke(!0)
+      IL_05e1:  add
+      IL_05e2:  stloc.s    V_49
+      IL_05e4:  ldloc.s    V_50
+      IL_05e6:  ldc.i4.1
+      IL_05e7:  add
+      IL_05e8:  stloc.s    V_50
+      IL_05ea:  ldloc.s    V_47
+      IL_05ec:  callvirt   instance bool [netstandard]System.Collections.IEnumerator::MoveNext()
+      IL_05f1:  brtrue.s   IL_05d1
+
+      IL_05f3:  ldloc.s    V_50
+      IL_05f5:  brtrue.s   IL_0602
+
+      IL_05f7:  ldstr      "source"
+      IL_05fc:  newobj     instance void [netstandard]System.InvalidOperationException::.ctor(string)
+      IL_0601:  throw
+
+      IL_0602:  nop
+      IL_0603:  ldloc.s    V_49
+      IL_0605:  stloc.s    V_51
+      IL_0607:  ldloc.s    V_50
+      IL_0609:  stloc.s    V_52
+      IL_060b:  ldloc.s    V_51
+      IL_060d:  ldloc.s    V_52
+      IL_060f:  conv.r8
+      IL_0610:  div
+      IL_0611:  stloc.s    V_48
+      IL_0613:  leave.s    IL_062b
+
+    }  
+    finally
+    {
+      IL_0615:  ldloc.s    V_47
+      IL_0617:  isinst     [runtime]System.IDisposable
+      IL_061c:  stloc.s    V_53
+      IL_061e:  ldloc.s    V_53
+      IL_0620:  brfalse.s  IL_062a
+
+      IL_0622:  ldloc.s    V_53
+      IL_0624:  callvirt   instance void [netstandard]System.IDisposable::Dispose()
+      IL_0629:  endfinally
+      IL_062a:  endfinally
+    }  
+    IL_062b:  ldloc.s    V_48
+    IL_062d:  stsfld     float64 assembly::averageLength@103
+    IL_0632:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0637:  stloc.s    V_55
+    IL_0639:  ldloc.s    V_55
+    IL_063b:  ldloc.s    V_55
+    IL_063d:  ldloc.s    V_55
+    IL_063f:  ldloc.s    V_55
+    IL_0641:  ldloc.s    V_55
+    IL_0643:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_0648:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_064d:  ldloc.s    V_55
+    IL_064f:  newobj     instance void assembly/'Pipe #7 input at line 112@113'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0654:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0659:  ldsfld     class assembly/'Pipe #7 input at line 112@114-1' assembly/'Pipe #7 input at line 112@114-1'::@_instance
+    IL_065e:  ldsfld     class assembly/'Pipe #7 input at line 112@114-2' assembly/'Pipe #7 input at line 112@114-2'::@_instance
+    IL_0663:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_0668:  ldloc.s    V_55
+    IL_066a:  newobj     instance void assembly/'Pipe #7 input at line 112@114-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_066f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0674:  ldsfld     class assembly/'Pipe #7 input at line 112@116-4' assembly/'Pipe #7 input at line 112@116-4'::@_instance
+    IL_0679:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_067e:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0683:  stloc.s    V_54
+    IL_0685:  ldloc.s    V_54
+    IL_0687:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_068c:  stsfld     class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::categories6@111
+    IL_0691:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          factorsOf300()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_factorsOf300()
+  } 
+  .property int32 uniqueFactors()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_uniqueFactors()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property int32 numSum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_numSum()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property int32 totalChars()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_totalChars()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Tuple`2<string,int32>[]
+          categories()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,int32>[] assembly::get_categories()
+  } 
+  .property int32 minNum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_minNum()
+  } 
+  .property int32 shortestWord()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_shortestWord()
+  } 
+  .property class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[]
+          categories2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::get_categories2()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[]
+          categories3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::get_categories3()
+  } 
+  .property int32 maxNum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_maxNum()
+  } 
+  .property int32 longestLength()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_longestLength()
+  } 
+  .property class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[]
+          categories4()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::get_categories4()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[]
+          categories5()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::get_categories5()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64>
+          numbers2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<float64> assembly::get_numbers2()
+  } 
+  .property float64 averageNum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get float64 assembly::get_averageNum()
+  } 
+  .property float64 averageLength()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get float64 assembly::get_averageLength()
+  } 
+  .property class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[]
+          categories6()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,valuetype [runtime]System.Decimal>[] assembly::get_categories6()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOff.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOff.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOff.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOff.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOff.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOff.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOn.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOn.il.net472.debug.bsl
new file mode 100644
index 00000000000..c649190faa6
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOn.il.net472.debug.bsl
@@ -0,0 +1,1493 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname products12@12
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/products12@12::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [Utils]Utils/Product assembly/products12@12::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/products12@12::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/products12@12::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/products12@12::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      class [Utils]Utils/Product assembly/products12@12::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/products12@12::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/products12@12::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      class [Utils]Utils/Product assembly/products12@12::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/products12@12::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/products12@12::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/products12@12::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/products12@12::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/products12@12::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/products12@12::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/products12@12::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/products12@12::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                        int32,
+                                                                                        class [Utils]Utils/Product)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'products12@13-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field static assembly initonly class assembly/'products12@13-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_ProductID()
+      IL_0006:  ldc.i4.s   12
+      IL_0008:  ceq
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'products12@13-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'products12@13-1' assembly/'products12@13-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname startsWithO@22
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/startsWithO@22::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/startsWithO@22::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/startsWithO@22::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/startsWithO@22::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/startsWithO@22::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/startsWithO@22::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/startsWithO@22::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/startsWithO@22::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/startsWithO@22::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/startsWithO@22::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/startsWithO@22::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/startsWithO@22::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/startsWithO@22::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/startsWithO@22::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/startsWithO@22::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/startsWithO@22::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/startsWithO@22::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                         int32,
+                                                                                         string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'startsWithO@23-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,bool>
+  {
+    .field static assembly initonly class assembly/'startsWithO@23-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(string s) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.0
+      IL_0002:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+      IL_0007:  ldc.i4.s   111
+      IL_0009:  ceq
+      IL_000b:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'startsWithO@23-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'startsWithO@23-1' assembly/'startsWithO@23-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname firstNumOrDefault@31
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/firstNumOrDefault@31::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/firstNumOrDefault@31::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/firstNumOrDefault@31::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/firstNumOrDefault@31::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/firstNumOrDefault@31::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/firstNumOrDefault@31::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/firstNumOrDefault@31::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/firstNumOrDefault@31::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/firstNumOrDefault@31::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                               int32,
+                                                                                               int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname fourthLowNum@52
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/fourthLowNum@52::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/fourthLowNum@52::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers2()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/fourthLowNum@52::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/fourthLowNum@52::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/fourthLowNum@52::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/fourthLowNum@52::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/fourthLowNum@52::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/fourthLowNum@52::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/fourthLowNum@52::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/fourthLowNum@52::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/fourthLowNum@52::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/fourthLowNum@52::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                          int32,
+                                                                                          int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'fourthLowNum@53-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'fourthLowNum@53-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.5
+      IL_0002:  cgt
+      IL_0004:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'fourthLowNum@53-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'fourthLowNum@53-1' assembly/'fourthLowNum@53-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Product products12@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> strings@18
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly string startsWithO@20
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 firstNumOrDefault@29
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers2@48
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 fourthLowNum@50
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Product get_products12() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Product assembly::products12@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_strings() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::strings@18
+    IL_0005:  ret
+  } 
+
+  .method public specialname static string get_startsWithO() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     string assembly::startsWithO@20
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_firstNumOrDefault() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::firstNumOrDefault@29
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers2@48
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_fourthLowNum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::fourthLowNum@50
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2)
+    IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0005:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@8
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_000f:  stloc.0
+    IL_0010:  ldloc.0
+    IL_0011:  ldloc.0
+    IL_0012:  ldnull
+    IL_0013:  ldc.i4.0
+    IL_0014:  ldnull
+    IL_0015:  newobj     instance void assembly/products12@12::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                      int32,
+                                                                                      class [Utils]Utils/Product)
+    IL_001a:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_001f:  ldsfld     class assembly/'products12@13-1' assembly/'products12@13-1'::@_instance
+    IL_0024:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0029:  callvirt   instance !!0 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Head<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_002e:  stsfld     class [Utils]Utils/Product assembly::products12@10
+    IL_0033:  ldstr      "zero"
+    IL_0038:  ldstr      "one"
+    IL_003d:  ldstr      "two"
+    IL_0042:  ldstr      "three"
+    IL_0047:  ldstr      "four"
+    IL_004c:  ldstr      "five"
+    IL_0051:  ldstr      "six"
+    IL_0056:  ldstr      "seven"
+    IL_005b:  ldstr      "eight"
+    IL_0060:  ldstr      "nine"
+    IL_0065:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_006a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_006f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0074:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0079:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_007e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0083:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0088:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_008d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0092:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0097:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_009c:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::strings@18
+    IL_00a1:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00a6:  stloc.1
+    IL_00a7:  ldloc.1
+    IL_00a8:  ldloc.1
+    IL_00a9:  ldnull
+    IL_00aa:  ldc.i4.0
+    IL_00ab:  ldnull
+    IL_00ac:  newobj     instance void assembly/startsWithO@22::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                       int32,
+                                                                                       string)
+    IL_00b1:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00b6:  ldsfld     class assembly/'startsWithO@23-1' assembly/'startsWithO@23-1'::@_instance
+    IL_00bb:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00c0:  callvirt   instance !!0 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Head<string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_00c5:  stsfld     string assembly::startsWithO@20
+    IL_00ca:  nop
+    IL_00cb:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00d0:  ldnull
+    IL_00d1:  ldc.i4.0
+    IL_00d2:  ldc.i4.0
+    IL_00d3:  newobj     instance void assembly/firstNumOrDefault@31::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                             int32,
+                                                                                             int32)
+    IL_00d8:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00dd:  callvirt   instance !!0 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::HeadOrDefault<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_00e2:  stsfld     int32 assembly::firstNumOrDefault@29
+    IL_00e7:  ldc.i4.5
+    IL_00e8:  ldc.i4.4
+    IL_00e9:  ldc.i4.1
+    IL_00ea:  ldc.i4.3
+    IL_00eb:  ldc.i4.s   9
+    IL_00ed:  ldc.i4.8
+    IL_00ee:  ldc.i4.6
+    IL_00ef:  ldc.i4.7
+    IL_00f0:  ldc.i4.2
+    IL_00f1:  ldc.i4.0
+    IL_00f2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_00f7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00fc:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0101:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0106:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_010b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0110:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0115:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_011a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_011f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0124:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0129:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers2@48
+    IL_012e:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0133:  stloc.2
+    IL_0134:  ldloc.2
+    IL_0135:  ldloc.2
+    IL_0136:  ldnull
+    IL_0137:  ldc.i4.0
+    IL_0138:  ldc.i4.0
+    IL_0139:  newobj     instance void assembly/fourthLowNum@52::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                        int32,
+                                                                                        int32)
+    IL_013e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0143:  ldsfld     class assembly/'fourthLowNum@53-1' assembly/'fourthLowNum@53-1'::@_instance
+    IL_0148:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_014d:  ldc.i4.1
+    IL_014e:  callvirt   instance !!0 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Nth<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                 int32)
+    IL_0153:  stsfld     int32 assembly::fourthLowNum@50
+    IL_0158:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [Utils]Utils/Product products12()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Product assembly::get_products12()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          strings()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+  } 
+  .property string startsWithO()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get string assembly::get_startsWithO()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property int32 firstNumOrDefault()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_firstNumOrDefault()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers2()
+  } 
+  .property int32 fourthLowNum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_fourthLowNum()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOn.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOn.il.net472.release.bsl
new file mode 100644
index 00000000000..c649190faa6
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOn.il.net472.release.bsl
@@ -0,0 +1,1493 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname products12@12
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/products12@12::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [Utils]Utils/Product assembly/products12@12::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/products12@12::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/products12@12::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/products12@12::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      class [Utils]Utils/Product assembly/products12@12::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/products12@12::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/products12@12::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      class [Utils]Utils/Product assembly/products12@12::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/products12@12::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/products12@12::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/products12@12::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/products12@12::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/products12@12::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/products12@12::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/products12@12::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/products12@12::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                        int32,
+                                                                                        class [Utils]Utils/Product)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'products12@13-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field static assembly initonly class assembly/'products12@13-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_ProductID()
+      IL_0006:  ldc.i4.s   12
+      IL_0008:  ceq
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'products12@13-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'products12@13-1' assembly/'products12@13-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname startsWithO@22
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/startsWithO@22::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/startsWithO@22::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/startsWithO@22::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/startsWithO@22::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/startsWithO@22::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/startsWithO@22::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/startsWithO@22::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/startsWithO@22::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/startsWithO@22::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/startsWithO@22::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/startsWithO@22::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/startsWithO@22::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/startsWithO@22::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/startsWithO@22::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/startsWithO@22::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/startsWithO@22::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/startsWithO@22::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                         int32,
+                                                                                         string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'startsWithO@23-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,bool>
+  {
+    .field static assembly initonly class assembly/'startsWithO@23-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(string s) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.0
+      IL_0002:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+      IL_0007:  ldc.i4.s   111
+      IL_0009:  ceq
+      IL_000b:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'startsWithO@23-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'startsWithO@23-1' assembly/'startsWithO@23-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname firstNumOrDefault@31
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/firstNumOrDefault@31::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/firstNumOrDefault@31::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/firstNumOrDefault@31::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/firstNumOrDefault@31::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/firstNumOrDefault@31::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/firstNumOrDefault@31::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/firstNumOrDefault@31::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/firstNumOrDefault@31::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/firstNumOrDefault@31::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                               int32,
+                                                                                               int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname fourthLowNum@52
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/fourthLowNum@52::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/fourthLowNum@52::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers2()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/fourthLowNum@52::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/fourthLowNum@52::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/fourthLowNum@52::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/fourthLowNum@52::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/fourthLowNum@52::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/fourthLowNum@52::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/fourthLowNum@52::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/fourthLowNum@52::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/fourthLowNum@52::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/fourthLowNum@52::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                          int32,
+                                                                                          int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'fourthLowNum@53-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'fourthLowNum@53-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.5
+      IL_0002:  cgt
+      IL_0004:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'fourthLowNum@53-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'fourthLowNum@53-1' assembly/'fourthLowNum@53-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Product products12@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> strings@18
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly string startsWithO@20
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 firstNumOrDefault@29
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers2@48
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 fourthLowNum@50
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Product get_products12() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Product assembly::products12@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_strings() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::strings@18
+    IL_0005:  ret
+  } 
+
+  .method public specialname static string get_startsWithO() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     string assembly::startsWithO@20
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_firstNumOrDefault() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::firstNumOrDefault@29
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers2@48
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_fourthLowNum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::fourthLowNum@50
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2)
+    IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0005:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@8
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_000f:  stloc.0
+    IL_0010:  ldloc.0
+    IL_0011:  ldloc.0
+    IL_0012:  ldnull
+    IL_0013:  ldc.i4.0
+    IL_0014:  ldnull
+    IL_0015:  newobj     instance void assembly/products12@12::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                      int32,
+                                                                                      class [Utils]Utils/Product)
+    IL_001a:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_001f:  ldsfld     class assembly/'products12@13-1' assembly/'products12@13-1'::@_instance
+    IL_0024:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0029:  callvirt   instance !!0 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Head<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_002e:  stsfld     class [Utils]Utils/Product assembly::products12@10
+    IL_0033:  ldstr      "zero"
+    IL_0038:  ldstr      "one"
+    IL_003d:  ldstr      "two"
+    IL_0042:  ldstr      "three"
+    IL_0047:  ldstr      "four"
+    IL_004c:  ldstr      "five"
+    IL_0051:  ldstr      "six"
+    IL_0056:  ldstr      "seven"
+    IL_005b:  ldstr      "eight"
+    IL_0060:  ldstr      "nine"
+    IL_0065:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_006a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_006f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0074:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0079:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_007e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0083:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0088:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_008d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0092:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0097:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_009c:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::strings@18
+    IL_00a1:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00a6:  stloc.1
+    IL_00a7:  ldloc.1
+    IL_00a8:  ldloc.1
+    IL_00a9:  ldnull
+    IL_00aa:  ldc.i4.0
+    IL_00ab:  ldnull
+    IL_00ac:  newobj     instance void assembly/startsWithO@22::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                       int32,
+                                                                                       string)
+    IL_00b1:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00b6:  ldsfld     class assembly/'startsWithO@23-1' assembly/'startsWithO@23-1'::@_instance
+    IL_00bb:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00c0:  callvirt   instance !!0 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Head<string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_00c5:  stsfld     string assembly::startsWithO@20
+    IL_00ca:  nop
+    IL_00cb:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00d0:  ldnull
+    IL_00d1:  ldc.i4.0
+    IL_00d2:  ldc.i4.0
+    IL_00d3:  newobj     instance void assembly/firstNumOrDefault@31::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                             int32,
+                                                                                             int32)
+    IL_00d8:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00dd:  callvirt   instance !!0 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::HeadOrDefault<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_00e2:  stsfld     int32 assembly::firstNumOrDefault@29
+    IL_00e7:  ldc.i4.5
+    IL_00e8:  ldc.i4.4
+    IL_00e9:  ldc.i4.1
+    IL_00ea:  ldc.i4.3
+    IL_00eb:  ldc.i4.s   9
+    IL_00ed:  ldc.i4.8
+    IL_00ee:  ldc.i4.6
+    IL_00ef:  ldc.i4.7
+    IL_00f0:  ldc.i4.2
+    IL_00f1:  ldc.i4.0
+    IL_00f2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_00f7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00fc:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0101:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0106:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_010b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0110:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0115:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_011a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_011f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0124:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0129:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers2@48
+    IL_012e:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0133:  stloc.2
+    IL_0134:  ldloc.2
+    IL_0135:  ldloc.2
+    IL_0136:  ldnull
+    IL_0137:  ldc.i4.0
+    IL_0138:  ldc.i4.0
+    IL_0139:  newobj     instance void assembly/fourthLowNum@52::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                        int32,
+                                                                                        int32)
+    IL_013e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0143:  ldsfld     class assembly/'fourthLowNum@53-1' assembly/'fourthLowNum@53-1'::@_instance
+    IL_0148:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_014d:  ldc.i4.1
+    IL_014e:  callvirt   instance !!0 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Nth<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                 int32)
+    IL_0153:  stsfld     int32 assembly::fourthLowNum@50
+    IL_0158:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [Utils]Utils/Product products12()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Product assembly::get_products12()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          strings()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+  } 
+  .property string startsWithO()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get string assembly::get_startsWithO()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property int32 firstNumOrDefault()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_firstNumOrDefault()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers2()
+  } 
+  .property int32 fourthLowNum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_fourthLowNum()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOn.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
new file mode 100644
index 00000000000..fee4817e146
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
@@ -0,0 +1,1493 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname products12@12
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/products12@12::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [Utils]Utils/Product assembly/products12@12::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/products12@12::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/products12@12::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/products12@12::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      class [Utils]Utils/Product assembly/products12@12::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/products12@12::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/products12@12::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      class [Utils]Utils/Product assembly/products12@12::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/products12@12::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/products12@12::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/products12@12::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/products12@12::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/products12@12::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/products12@12::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/products12@12::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/products12@12::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                        int32,
+                                                                                        class [Utils]Utils/Product)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'products12@13-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field static assembly initonly class assembly/'products12@13-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_ProductID()
+      IL_0006:  ldc.i4.s   12
+      IL_0008:  ceq
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'products12@13-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'products12@13-1' assembly/'products12@13-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname startsWithO@22
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/startsWithO@22::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/startsWithO@22::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/startsWithO@22::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/startsWithO@22::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/startsWithO@22::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/startsWithO@22::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/startsWithO@22::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/startsWithO@22::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/startsWithO@22::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/startsWithO@22::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/startsWithO@22::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/startsWithO@22::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/startsWithO@22::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/startsWithO@22::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/startsWithO@22::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/startsWithO@22::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/startsWithO@22::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                         int32,
+                                                                                         string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'startsWithO@23-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,bool>
+  {
+    .field static assembly initonly class assembly/'startsWithO@23-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(string s) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.0
+      IL_0002:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+      IL_0007:  ldc.i4.s   111
+      IL_0009:  ceq
+      IL_000b:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'startsWithO@23-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'startsWithO@23-1' assembly/'startsWithO@23-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname firstNumOrDefault@31
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/firstNumOrDefault@31::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/firstNumOrDefault@31::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/firstNumOrDefault@31::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/firstNumOrDefault@31::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/firstNumOrDefault@31::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/firstNumOrDefault@31::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/firstNumOrDefault@31::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/firstNumOrDefault@31::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/firstNumOrDefault@31::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                               int32,
+                                                                                               int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname fourthLowNum@52
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/fourthLowNum@52::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/fourthLowNum@52::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers2()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/fourthLowNum@52::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/fourthLowNum@52::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/fourthLowNum@52::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/fourthLowNum@52::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/fourthLowNum@52::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/fourthLowNum@52::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/fourthLowNum@52::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/fourthLowNum@52::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/fourthLowNum@52::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/fourthLowNum@52::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                          int32,
+                                                                                          int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'fourthLowNum@53-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'fourthLowNum@53-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.5
+      IL_0002:  cgt
+      IL_0004:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'fourthLowNum@53-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'fourthLowNum@53-1' assembly/'fourthLowNum@53-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Product products12@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> strings@18
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly string startsWithO@20
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 firstNumOrDefault@29
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers2@48
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 fourthLowNum@50
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Product get_products12() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Product assembly::products12@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_strings() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::strings@18
+    IL_0005:  ret
+  } 
+
+  .method public specialname static string get_startsWithO() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     string assembly::startsWithO@20
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_firstNumOrDefault() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::firstNumOrDefault@29
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers2@48
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_fourthLowNum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::fourthLowNum@50
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2)
+    IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0005:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@8
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_000f:  stloc.0
+    IL_0010:  ldloc.0
+    IL_0011:  ldloc.0
+    IL_0012:  ldnull
+    IL_0013:  ldc.i4.0
+    IL_0014:  ldnull
+    IL_0015:  newobj     instance void assembly/products12@12::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                      int32,
+                                                                                      class [Utils]Utils/Product)
+    IL_001a:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_001f:  ldsfld     class assembly/'products12@13-1' assembly/'products12@13-1'::@_instance
+    IL_0024:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0029:  callvirt   instance !!0 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Head<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_002e:  stsfld     class [Utils]Utils/Product assembly::products12@10
+    IL_0033:  ldstr      "zero"
+    IL_0038:  ldstr      "one"
+    IL_003d:  ldstr      "two"
+    IL_0042:  ldstr      "three"
+    IL_0047:  ldstr      "four"
+    IL_004c:  ldstr      "five"
+    IL_0051:  ldstr      "six"
+    IL_0056:  ldstr      "seven"
+    IL_005b:  ldstr      "eight"
+    IL_0060:  ldstr      "nine"
+    IL_0065:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_006a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_006f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0074:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0079:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_007e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0083:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0088:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_008d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0092:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0097:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_009c:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::strings@18
+    IL_00a1:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00a6:  stloc.1
+    IL_00a7:  ldloc.1
+    IL_00a8:  ldloc.1
+    IL_00a9:  ldnull
+    IL_00aa:  ldc.i4.0
+    IL_00ab:  ldnull
+    IL_00ac:  newobj     instance void assembly/startsWithO@22::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                       int32,
+                                                                                       string)
+    IL_00b1:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00b6:  ldsfld     class assembly/'startsWithO@23-1' assembly/'startsWithO@23-1'::@_instance
+    IL_00bb:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00c0:  callvirt   instance !!0 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Head<string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_00c5:  stsfld     string assembly::startsWithO@20
+    IL_00ca:  nop
+    IL_00cb:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00d0:  ldnull
+    IL_00d1:  ldc.i4.0
+    IL_00d2:  ldc.i4.0
+    IL_00d3:  newobj     instance void assembly/firstNumOrDefault@31::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                             int32,
+                                                                                             int32)
+    IL_00d8:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00dd:  callvirt   instance !!0 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::HeadOrDefault<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_00e2:  stsfld     int32 assembly::firstNumOrDefault@29
+    IL_00e7:  ldc.i4.5
+    IL_00e8:  ldc.i4.4
+    IL_00e9:  ldc.i4.1
+    IL_00ea:  ldc.i4.3
+    IL_00eb:  ldc.i4.s   9
+    IL_00ed:  ldc.i4.8
+    IL_00ee:  ldc.i4.6
+    IL_00ef:  ldc.i4.7
+    IL_00f0:  ldc.i4.2
+    IL_00f1:  ldc.i4.0
+    IL_00f2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_00f7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00fc:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0101:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0106:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_010b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0110:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0115:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_011a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_011f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0124:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0129:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers2@48
+    IL_012e:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0133:  stloc.2
+    IL_0134:  ldloc.2
+    IL_0135:  ldloc.2
+    IL_0136:  ldnull
+    IL_0137:  ldc.i4.0
+    IL_0138:  ldc.i4.0
+    IL_0139:  newobj     instance void assembly/fourthLowNum@52::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                        int32,
+                                                                                        int32)
+    IL_013e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0143:  ldsfld     class assembly/'fourthLowNum@53-1' assembly/'fourthLowNum@53-1'::@_instance
+    IL_0148:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_014d:  ldc.i4.1
+    IL_014e:  callvirt   instance !!0 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Nth<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                       int32)
+    IL_0153:  stsfld     int32 assembly::fourthLowNum@50
+    IL_0158:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [Utils]Utils/Product products12()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Product assembly::get_products12()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          strings()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+  } 
+  .property string startsWithO()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get string assembly::get_startsWithO()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property int32 firstNumOrDefault()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_firstNumOrDefault()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers2()
+  } 
+  .property int32 fourthLowNum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_fourthLowNum()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOn.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOn.il.netcore.release.bsl
new file mode 100644
index 00000000000..fee4817e146
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101ElementOperators01.fs.RealInternalSignatureOn.il.netcore.release.bsl
@@ -0,0 +1,1493 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname products12@12
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/products12@12::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [Utils]Utils/Product assembly/products12@12::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/products12@12::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/products12@12::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/products12@12::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      class [Utils]Utils/Product assembly/products12@12::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/products12@12::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/products12@12::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      class [Utils]Utils/Product assembly/products12@12::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/products12@12::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/products12@12::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/products12@12::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/products12@12::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/products12@12::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/products12@12::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/products12@12::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/products12@12::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/products12@12::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                        int32,
+                                                                                        class [Utils]Utils/Product)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'products12@13-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field static assembly initonly class assembly/'products12@13-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_ProductID()
+      IL_0006:  ldc.i4.s   12
+      IL_0008:  ceq
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'products12@13-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'products12@13-1' assembly/'products12@13-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname startsWithO@22
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/startsWithO@22::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/startsWithO@22::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/startsWithO@22::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/startsWithO@22::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/startsWithO@22::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/startsWithO@22::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/startsWithO@22::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/startsWithO@22::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/startsWithO@22::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/startsWithO@22::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/startsWithO@22::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/startsWithO@22::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/startsWithO@22::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/startsWithO@22::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/startsWithO@22::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/startsWithO@22::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/startsWithO@22::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/startsWithO@22::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                         int32,
+                                                                                         string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'startsWithO@23-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,bool>
+  {
+    .field static assembly initonly class assembly/'startsWithO@23-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(string s) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.0
+      IL_0002:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+      IL_0007:  ldc.i4.s   111
+      IL_0009:  ceq
+      IL_000b:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'startsWithO@23-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'startsWithO@23-1' assembly/'startsWithO@23-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname firstNumOrDefault@31
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/firstNumOrDefault@31::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/firstNumOrDefault@31::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/firstNumOrDefault@31::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/firstNumOrDefault@31::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/firstNumOrDefault@31::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/firstNumOrDefault@31::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/firstNumOrDefault@31::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/firstNumOrDefault@31::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/firstNumOrDefault@31::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/firstNumOrDefault@31::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/firstNumOrDefault@31::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                               int32,
+                                                                                               int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname fourthLowNum@52
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/fourthLowNum@52::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/fourthLowNum@52::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers2()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/fourthLowNum@52::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/fourthLowNum@52::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/fourthLowNum@52::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/fourthLowNum@52::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/fourthLowNum@52::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/fourthLowNum@52::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/fourthLowNum@52::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/fourthLowNum@52::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/fourthLowNum@52::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/fourthLowNum@52::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/fourthLowNum@52::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/fourthLowNum@52::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                          int32,
+                                                                                          int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'fourthLowNum@53-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'fourthLowNum@53-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.5
+      IL_0002:  cgt
+      IL_0004:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'fourthLowNum@53-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'fourthLowNum@53-1' assembly/'fourthLowNum@53-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Product products12@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> strings@18
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly string startsWithO@20
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 firstNumOrDefault@29
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers2@48
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 fourthLowNum@50
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Product get_products12() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Product assembly::products12@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_strings() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::strings@18
+    IL_0005:  ret
+  } 
+
+  .method public specialname static string get_startsWithO() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     string assembly::startsWithO@20
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_firstNumOrDefault() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::firstNumOrDefault@29
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers2@48
+    IL_0005:  ret
+  } 
+
+  .method public specialname static int32 get_fourthLowNum() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 assembly::fourthLowNum@50
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2)
+    IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0005:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@8
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_000f:  stloc.0
+    IL_0010:  ldloc.0
+    IL_0011:  ldloc.0
+    IL_0012:  ldnull
+    IL_0013:  ldc.i4.0
+    IL_0014:  ldnull
+    IL_0015:  newobj     instance void assembly/products12@12::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                      int32,
+                                                                                      class [Utils]Utils/Product)
+    IL_001a:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_001f:  ldsfld     class assembly/'products12@13-1' assembly/'products12@13-1'::@_instance
+    IL_0024:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0029:  callvirt   instance !!0 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Head<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_002e:  stsfld     class [Utils]Utils/Product assembly::products12@10
+    IL_0033:  ldstr      "zero"
+    IL_0038:  ldstr      "one"
+    IL_003d:  ldstr      "two"
+    IL_0042:  ldstr      "three"
+    IL_0047:  ldstr      "four"
+    IL_004c:  ldstr      "five"
+    IL_0051:  ldstr      "six"
+    IL_0056:  ldstr      "seven"
+    IL_005b:  ldstr      "eight"
+    IL_0060:  ldstr      "nine"
+    IL_0065:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_006a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_006f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0074:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0079:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_007e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0083:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0088:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_008d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0092:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0097:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_009c:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::strings@18
+    IL_00a1:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00a6:  stloc.1
+    IL_00a7:  ldloc.1
+    IL_00a8:  ldloc.1
+    IL_00a9:  ldnull
+    IL_00aa:  ldc.i4.0
+    IL_00ab:  ldnull
+    IL_00ac:  newobj     instance void assembly/startsWithO@22::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                       int32,
+                                                                                       string)
+    IL_00b1:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00b6:  ldsfld     class assembly/'startsWithO@23-1' assembly/'startsWithO@23-1'::@_instance
+    IL_00bb:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00c0:  callvirt   instance !!0 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Head<string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_00c5:  stsfld     string assembly::startsWithO@20
+    IL_00ca:  nop
+    IL_00cb:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00d0:  ldnull
+    IL_00d1:  ldc.i4.0
+    IL_00d2:  ldc.i4.0
+    IL_00d3:  newobj     instance void assembly/firstNumOrDefault@31::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                             int32,
+                                                                                             int32)
+    IL_00d8:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00dd:  callvirt   instance !!0 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::HeadOrDefault<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_00e2:  stsfld     int32 assembly::firstNumOrDefault@29
+    IL_00e7:  ldc.i4.5
+    IL_00e8:  ldc.i4.4
+    IL_00e9:  ldc.i4.1
+    IL_00ea:  ldc.i4.3
+    IL_00eb:  ldc.i4.s   9
+    IL_00ed:  ldc.i4.8
+    IL_00ee:  ldc.i4.6
+    IL_00ef:  ldc.i4.7
+    IL_00f0:  ldc.i4.2
+    IL_00f1:  ldc.i4.0
+    IL_00f2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_00f7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00fc:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0101:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0106:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_010b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0110:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0115:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_011a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_011f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0124:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0129:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers2@48
+    IL_012e:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0133:  stloc.2
+    IL_0134:  ldloc.2
+    IL_0135:  ldloc.2
+    IL_0136:  ldnull
+    IL_0137:  ldc.i4.0
+    IL_0138:  ldc.i4.0
+    IL_0139:  newobj     instance void assembly/fourthLowNum@52::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                        int32,
+                                                                                        int32)
+    IL_013e:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0143:  ldsfld     class assembly/'fourthLowNum@53-1' assembly/'fourthLowNum@53-1'::@_instance
+    IL_0148:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_014d:  ldc.i4.1
+    IL_014e:  callvirt   instance !!0 [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Nth<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                       int32)
+    IL_0153:  stsfld     int32 assembly::fourthLowNum@50
+    IL_0158:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [Utils]Utils/Product products12()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Product assembly::get_products12()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          strings()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+  } 
+  .property string startsWithO()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get string assembly::get_startsWithO()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property int32 firstNumOrDefault()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_firstNumOrDefault()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers2()
+  } 
+  .property int32 fourthLowNum()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get int32 assembly::get_fourthLowNum()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOff.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOff.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOff.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOff.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOff.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOff.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOn.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOn.il.net472.debug.bsl
new file mode 100644
index 00000000000..3ac4071a8d2
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOn.il.net472.debug.bsl
@@ -0,0 +1,1540 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern System.Core
+{
+  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         
+  .ver 4:0:0:0
+}
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@14'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@14'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@14'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<int32,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@15-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@15-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@15-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@15-1' assembly/'Pipe #1 input at line 13@15-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@15-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@15-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.5
+      IL_0002:  rem
+      IL_0003:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@15-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@15-2' assembly/'Pipe #1 input at line 13@15-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@15-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,int32>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<int32,int32>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,int32>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<int32,int32>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@15-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<int32,int32>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<int32,int32> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<int32,int32> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@15-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Core]System.Linq.IGrouping`2<int32,int32>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@16-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,int32>,class [runtime]System.Tuple`2<int32,int32[]>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@16-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,int32>,class [runtime]System.Tuple`2<int32,int32[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,int32[]> Invoke(class [System.Core]System.Linq.IGrouping`2<int32,int32> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<int32,int32>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  call       !!0[] [System.Core]System.Linq.Enumerable::ToArray<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  newobj     instance void class [runtime]System.Tuple`2<int32,int32[]>::.ctor(!0,
+                                                                                              !1)
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@16-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@16-4' assembly/'Pipe #1 input at line 13@16-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@24'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 23@24'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,object> Invoke(string _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 23@24'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<string,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@25-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 23@25-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 23@25-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 23@25-1' assembly/'Pipe #2 input at line 23@25-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@25-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,char>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 23@25-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,char>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance char Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.0
+      IL_0002:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 23@25-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 23@25-2' assembly/'Pipe #2 input at line 23@25-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@25-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<char,string>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<char,string>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<char,string>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<char,string>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 23@25-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<char,string>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<char,string> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<char,string> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 23@25-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Core]System.Linq.IGrouping`2<char,string>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@26-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<char,string>,class [runtime]System.Tuple`2<char,string[]>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 23@26-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<char,string>,class [runtime]System.Tuple`2<char,string[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<char,string[]> Invoke(class [System.Core]System.Linq.IGrouping`2<char,string> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<char,string>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  call       !!0[] [System.Core]System.Linq.Enumerable::ToArray<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  newobj     instance void class [runtime]System.Tuple`2<char,string[]>::.ctor(!0,
+                                                                                              !1)
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 23@26-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 23@26-4' assembly/'Pipe #2 input at line 23@26-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@34'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 33@34'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 33@34'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@35-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 33@35-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 33@35-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 33@35-1' assembly/'Pipe #3 input at line 33@35-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@35-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 33@35-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 33@35-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 33@35-2' assembly/'Pipe #3 input at line 33@35-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@35-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 33@35-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 33@35-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@36-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 33@36-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  call       !!0[] [System.Core]System.Linq.Enumerable::ToArray<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  newobj     instance void class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>::.ctor(!0,
+                                                                                                                    !1)
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 33@36-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 33@36-4' assembly/'Pipe #3 input at line 33@36-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit yearGroups@47
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/yearGroups@47::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/yearGroups@47::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Order,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'yearGroups@48-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [Utils]Utils/Order>
+  {
+    .field static assembly initonly class assembly/'yearGroups@48-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [Utils]Utils/Order>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Order Invoke(class [Utils]Utils/Order o) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'yearGroups@48-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'yearGroups@48-1' assembly/'yearGroups@48-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'yearGroups@48-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,int32>
+  {
+    .field static assembly initonly class assembly/'yearGroups@48-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class [Utils]Utils/Order o) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (valuetype [runtime]System.DateTime V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  call       instance int32 [runtime]System.DateTime::get_Year()
+      IL_000e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'yearGroups@48-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'yearGroups@48-2' assembly/'yearGroups@48-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit monthGroups@51
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/monthGroups@51::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object> Invoke(class [Utils]Utils/Order _arg4) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/monthGroups@51::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Order,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'monthGroups@52-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [Utils]Utils/Order>
+  {
+    .field static assembly initonly class assembly/'monthGroups@52-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [Utils]Utils/Order>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Order Invoke(class [Utils]Utils/Order o) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'monthGroups@52-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'monthGroups@52-1' assembly/'monthGroups@52-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'monthGroups@52-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,int32>
+  {
+    .field static assembly initonly class assembly/'monthGroups@52-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class [Utils]Utils/Order o) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (valuetype [runtime]System.DateTime V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  call       instance int32 [runtime]System.DateTime::get_Month()
+      IL_000e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'monthGroups@52-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'monthGroups@52-2' assembly/'monthGroups@52-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'monthGroups@52-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'monthGroups@52-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> _arg5) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'monthGroups@52-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'monthGroups@53-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>
+  {
+    .field static assembly initonly class assembly/'monthGroups@53-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]> Invoke(class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> mg) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  call       !!0[] [System.Core]System.Linq.Enumerable::ToArray<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  newobj     instance void class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>::.ctor(!0,
+                                                                                                                 !1)
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'monthGroups@53-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'monthGroups@53-4' assembly/'monthGroups@53-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'yearGroups@48-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'yearGroups@48-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> _arg3) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>> V_1,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  stloc.2
+      IL_0008:  ldloc.2
+      IL_0009:  ldloc.2
+      IL_000a:  ldloc.2
+      IL_000b:  ldloc.2
+      IL_000c:  ldloc.2
+      IL_000d:  ldloc.0
+      IL_000e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0013:  ldloc.2
+      IL_0014:  newobj     instance void assembly/monthGroups@51::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+      IL_0019:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Order,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_001e:  ldsfld     class assembly/'monthGroups@52-1' assembly/'monthGroups@52-1'::@_instance
+      IL_0023:  ldsfld     class assembly/'monthGroups@52-2' assembly/'monthGroups@52-2'::@_instance
+      IL_0028:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Order,int32,class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+      IL_002d:  ldloc.2
+      IL_002e:  newobj     instance void assembly/'monthGroups@52-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+      IL_0033:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_0038:  ldsfld     class assembly/'monthGroups@53-4' assembly/'monthGroups@53-4'::@_instance
+      IL_003d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_0042:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_0047:  stloc.1
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'yearGroups@48-3'::builder@
+      IL_004e:  ldloc.0
+      IL_004f:  ldloc.1
+      IL_0050:  newobj     instance void class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>::.ctor(!0,
+                                                                                                                                                                                                                                                                                      !1)
+      IL_0055:  tail.
+      IL_0057:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object>(!!0)
+      IL_005c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'yearGroups@55-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>
+  {
+    .field static assembly initonly class assembly/'yearGroups@55-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]> Invoke(class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>> V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  call       !!0[] [System.Core]System.Linq.Enumerable::ToArray<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_001a:  newobj     instance void class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>::.ctor(!0,
+                                                                                                                                                         !1)
+      IL_001f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'yearGroups@55-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'yearGroups@55-4' assembly/'yearGroups@55-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 43@44'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 43@44'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>> V_1,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  stloc.2
+      IL_0008:  ldloc.2
+      IL_0009:  ldloc.2
+      IL_000a:  ldloc.2
+      IL_000b:  ldloc.2
+      IL_000c:  ldloc.2
+      IL_000d:  ldloc.0
+      IL_000e:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0013:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0018:  ldloc.2
+      IL_0019:  newobj     instance void assembly/yearGroups@47::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+      IL_001e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Order,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_0023:  ldsfld     class assembly/'yearGroups@48-1' assembly/'yearGroups@48-1'::@_instance
+      IL_0028:  ldsfld     class assembly/'yearGroups@48-2' assembly/'yearGroups@48-2'::@_instance
+      IL_002d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Order,int32,class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+      IL_0032:  ldloc.2
+      IL_0033:  newobj     instance void assembly/'yearGroups@48-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+      IL_0038:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_003d:  ldsfld     class assembly/'yearGroups@55-4' assembly/'yearGroups@55-4'::@_instance
+      IL_0042:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_0047:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 43@44'::builder@
+      IL_0053:  ldloc.0
+      IL_0054:  ldloc.1
+      IL_0055:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>::.ctor(!0,
+                                                                                                                                                                                                                                                                               !1)
+      IL_005a:  tail.
+      IL_005c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object>(!!0)
+      IL_0061:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 43@57-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 43@57-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>> V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CompanyName()
+      IL_0014:  ldloc.1
+      IL_0015:  call       !!0[] [System.Core]System.Linq.Enumerable::ToArray<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_001a:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>::.ctor(!0,
+                                                                                                                                                                                                  !1)
+      IL_001f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 43@57-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 43@57-1' assembly/'Pipe #4 input at line 43@57-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> digits@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<int32,int32[]>[] numberGroups@12
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@20
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<char,string[]>[] wordGroups@22
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@30
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] orderGroups@32
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@40
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] customerOrderGroups@42
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_digits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@7
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<int32,int32[]>[] get_numberGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<int32,int32[]>[] assembly::numberGroups@12
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@20
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<char,string[]>[] get_wordGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<char,string[]>[] assembly::wordGroups@22
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@30
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] get_orderGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] assembly::orderGroups@32
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@40
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] get_customerOrderGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] assembly::customerOrderGroups@42
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,int32[]>> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<char,string[]>> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7)
+    IL_0000:  ldstr      "zero"
+    IL_0005:  ldstr      "one"
+    IL_000a:  ldstr      "two"
+    IL_000f:  ldstr      "three"
+    IL_0014:  ldstr      "four"
+    IL_0019:  ldstr      "five"
+    IL_001e:  ldstr      "six"
+    IL_0023:  ldstr      "seven"
+    IL_0028:  ldstr      "eight"
+    IL_002d:  ldstr      "nine"
+    IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0037:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_003c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0041:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0046:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_004b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0050:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0055:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_005a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_005f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0064:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0069:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@7
+    IL_006e:  ldc.i4.5
+    IL_006f:  ldc.i4.4
+    IL_0070:  ldc.i4.1
+    IL_0071:  ldc.i4.3
+    IL_0072:  ldc.i4.s   9
+    IL_0074:  ldc.i4.8
+    IL_0075:  ldc.i4.6
+    IL_0076:  ldc.i4.7
+    IL_0077:  ldc.i4.2
+    IL_0078:  ldc.i4.0
+    IL_0079:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_007e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0083:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0088:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_008d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0092:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0097:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_009c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00a1:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00a6:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00ab:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00b0:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@10
+    IL_00b5:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00ba:  stloc.1
+    IL_00bb:  ldloc.1
+    IL_00bc:  ldloc.1
+    IL_00bd:  ldloc.1
+    IL_00be:  ldloc.1
+    IL_00bf:  ldloc.1
+    IL_00c0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+    IL_00c5:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00ca:  ldloc.1
+    IL_00cb:  newobj     instance void assembly/'Pipe #1 input at line 13@14'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00d0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,int32,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00d5:  ldsfld     class assembly/'Pipe #1 input at line 13@15-1' assembly/'Pipe #1 input at line 13@15-1'::@_instance
+    IL_00da:  ldsfld     class assembly/'Pipe #1 input at line 13@15-2' assembly/'Pipe #1 input at line 13@15-2'::@_instance
+    IL_00df:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<int32,int32,int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_00e4:  ldloc.1
+    IL_00e5:  newobj     instance void assembly/'Pipe #1 input at line 13@15-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00ea:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<int32,int32>,class [runtime]System.Collections.IEnumerable,class [System.Core]System.Linq.IGrouping`2<int32,int32>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00ef:  ldsfld     class assembly/'Pipe #1 input at line 13@16-4' assembly/'Pipe #1 input at line 13@16-4'::@_instance
+    IL_00f4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Core]System.Linq.IGrouping`2<int32,int32>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,int32[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00f9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00fe:  stloc.0
+    IL_00ff:  ldloc.0
+    IL_0100:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<int32,int32[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0105:  stsfld     class [runtime]System.Tuple`2<int32,int32[]>[] assembly::numberGroups@12
+    IL_010a:  ldstr      "blueberry"
+    IL_010f:  ldstr      "chimpanzee"
+    IL_0114:  ldstr      "abacus"
+    IL_0119:  ldstr      "banana"
+    IL_011e:  ldstr      "apple"
+    IL_0123:  ldstr      "cheese"
+    IL_0128:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_012d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0132:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0137:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_013c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0141:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0146:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_014b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@20
+    IL_0150:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0155:  stloc.3
+    IL_0156:  ldloc.3
+    IL_0157:  ldloc.3
+    IL_0158:  ldloc.3
+    IL_0159:  ldloc.3
+    IL_015a:  ldloc.3
+    IL_015b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+    IL_0160:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0165:  ldloc.3
+    IL_0166:  newobj     instance void assembly/'Pipe #2 input at line 23@24'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_016b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<string,class [runtime]System.Collections.IEnumerable,string,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0170:  ldsfld     class assembly/'Pipe #2 input at line 23@25-1' assembly/'Pipe #2 input at line 23@25-1'::@_instance
+    IL_0175:  ldsfld     class assembly/'Pipe #2 input at line 23@25-2' assembly/'Pipe #2 input at line 23@25-2'::@_instance
+    IL_017a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<string,char,string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_017f:  ldloc.3
+    IL_0180:  newobj     instance void assembly/'Pipe #2 input at line 23@25-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0185:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<char,string>,class [runtime]System.Collections.IEnumerable,class [System.Core]System.Linq.IGrouping`2<char,string>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_018a:  ldsfld     class assembly/'Pipe #2 input at line 23@26-4' assembly/'Pipe #2 input at line 23@26-4'::@_instance
+    IL_018f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Core]System.Linq.IGrouping`2<char,string>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<char,string[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0194:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<char,string[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0199:  stloc.2
+    IL_019a:  ldloc.2
+    IL_019b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<char,string[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01a0:  stsfld     class [runtime]System.Tuple`2<char,string[]>[] assembly::wordGroups@22
+    IL_01a5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_01aa:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@30
+    IL_01af:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_01b4:  stloc.s    V_5
+    IL_01b6:  ldloc.s    V_5
+    IL_01b8:  ldloc.s    V_5
+    IL_01ba:  ldloc.s    V_5
+    IL_01bc:  ldloc.s    V_5
+    IL_01be:  ldloc.s    V_5
+    IL_01c0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_01c5:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01ca:  ldloc.s    V_5
+    IL_01cc:  newobj     instance void assembly/'Pipe #3 input at line 33@34'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01d1:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01d6:  ldsfld     class assembly/'Pipe #3 input at line 33@35-1' assembly/'Pipe #3 input at line 33@35-1'::@_instance
+    IL_01db:  ldsfld     class assembly/'Pipe #3 input at line 33@35-2' assembly/'Pipe #3 input at line 33@35-2'::@_instance
+    IL_01e0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_01e5:  ldloc.s    V_5
+    IL_01e7:  newobj     instance void assembly/'Pipe #3 input at line 33@35-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01ec:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01f1:  ldsfld     class assembly/'Pipe #3 input at line 33@36-4' assembly/'Pipe #3 input at line 33@36-4'::@_instance
+    IL_01f6:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01fb:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0200:  stloc.s    V_4
+    IL_0202:  ldloc.s    V_4
+    IL_0204:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0209:  stsfld     class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] assembly::orderGroups@32
+    IL_020e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_0213:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@40
+    IL_0218:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_021d:  stloc.s    V_7
+    IL_021f:  ldloc.s    V_7
+    IL_0221:  ldloc.s    V_7
+    IL_0223:  ldloc.s    V_7
+    IL_0225:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_022a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_022f:  ldloc.s    V_7
+    IL_0231:  newobj     instance void assembly/'Pipe #4 input at line 43@44'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0236:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_023b:  ldsfld     class assembly/'Pipe #4 input at line 43@57-1' assembly/'Pipe #4 input at line 43@57-1'::@_instance
+    IL_0240:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0245:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_024a:  stloc.s    V_6
+    IL_024c:  ldloc.s    V_6
+    IL_024e:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0253:  stsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] assembly::customerOrderGroups@42
+    IL_0258:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          digits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property class [runtime]System.Tuple`2<int32,int32[]>[]
+          numberGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<int32,int32[]>[] assembly::get_numberGroups()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property class [runtime]System.Tuple`2<char,string[]>[]
+          wordGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<char,string[]>[] assembly::get_wordGroups()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[]
+          orderGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] assembly::get_orderGroups()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[]
+          customerOrderGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] assembly::get_customerOrderGroups()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOn.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOn.il.net472.release.bsl
new file mode 100644
index 00000000000..3ac4071a8d2
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOn.il.net472.release.bsl
@@ -0,0 +1,1540 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern System.Core
+{
+  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         
+  .ver 4:0:0:0
+}
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@14'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@14'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@14'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<int32,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@15-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@15-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@15-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@15-1' assembly/'Pipe #1 input at line 13@15-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@15-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@15-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.5
+      IL_0002:  rem
+      IL_0003:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@15-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@15-2' assembly/'Pipe #1 input at line 13@15-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@15-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,int32>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<int32,int32>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,int32>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<int32,int32>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@15-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<int32,int32>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<int32,int32> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<int32,int32> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@15-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Core]System.Linq.IGrouping`2<int32,int32>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@16-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,int32>,class [runtime]System.Tuple`2<int32,int32[]>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@16-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,int32>,class [runtime]System.Tuple`2<int32,int32[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,int32[]> Invoke(class [System.Core]System.Linq.IGrouping`2<int32,int32> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<int32,int32>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  call       !!0[] [System.Core]System.Linq.Enumerable::ToArray<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  newobj     instance void class [runtime]System.Tuple`2<int32,int32[]>::.ctor(!0,
+                                                                                              !1)
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@16-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@16-4' assembly/'Pipe #1 input at line 13@16-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@24'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 23@24'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,object> Invoke(string _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 23@24'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<string,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@25-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 23@25-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 23@25-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 23@25-1' assembly/'Pipe #2 input at line 23@25-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@25-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,char>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 23@25-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,char>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance char Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.0
+      IL_0002:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 23@25-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 23@25-2' assembly/'Pipe #2 input at line 23@25-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@25-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<char,string>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<char,string>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<char,string>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<char,string>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 23@25-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<char,string>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<char,string> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<char,string> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 23@25-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Core]System.Linq.IGrouping`2<char,string>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@26-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<char,string>,class [runtime]System.Tuple`2<char,string[]>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 23@26-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<char,string>,class [runtime]System.Tuple`2<char,string[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<char,string[]> Invoke(class [System.Core]System.Linq.IGrouping`2<char,string> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<char,string>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  call       !!0[] [System.Core]System.Linq.Enumerable::ToArray<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  newobj     instance void class [runtime]System.Tuple`2<char,string[]>::.ctor(!0,
+                                                                                              !1)
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 23@26-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 23@26-4' assembly/'Pipe #2 input at line 23@26-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@34'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 33@34'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 33@34'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@35-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 33@35-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 33@35-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 33@35-1' assembly/'Pipe #3 input at line 33@35-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@35-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 33@35-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 33@35-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 33@35-2' assembly/'Pipe #3 input at line 33@35-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@35-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 33@35-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 33@35-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@36-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 33@36-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  call       !!0[] [System.Core]System.Linq.Enumerable::ToArray<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  newobj     instance void class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>::.ctor(!0,
+                                                                                                                    !1)
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 33@36-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 33@36-4' assembly/'Pipe #3 input at line 33@36-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit yearGroups@47
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/yearGroups@47::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/yearGroups@47::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Order,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'yearGroups@48-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [Utils]Utils/Order>
+  {
+    .field static assembly initonly class assembly/'yearGroups@48-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [Utils]Utils/Order>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Order Invoke(class [Utils]Utils/Order o) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'yearGroups@48-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'yearGroups@48-1' assembly/'yearGroups@48-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'yearGroups@48-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,int32>
+  {
+    .field static assembly initonly class assembly/'yearGroups@48-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class [Utils]Utils/Order o) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (valuetype [runtime]System.DateTime V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  call       instance int32 [runtime]System.DateTime::get_Year()
+      IL_000e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'yearGroups@48-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'yearGroups@48-2' assembly/'yearGroups@48-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit monthGroups@51
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/monthGroups@51::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object> Invoke(class [Utils]Utils/Order _arg4) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/monthGroups@51::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Order,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'monthGroups@52-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [Utils]Utils/Order>
+  {
+    .field static assembly initonly class assembly/'monthGroups@52-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [Utils]Utils/Order>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Order Invoke(class [Utils]Utils/Order o) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'monthGroups@52-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'monthGroups@52-1' assembly/'monthGroups@52-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'monthGroups@52-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,int32>
+  {
+    .field static assembly initonly class assembly/'monthGroups@52-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class [Utils]Utils/Order o) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (valuetype [runtime]System.DateTime V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  call       instance int32 [runtime]System.DateTime::get_Month()
+      IL_000e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'monthGroups@52-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'monthGroups@52-2' assembly/'monthGroups@52-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'monthGroups@52-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'monthGroups@52-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> _arg5) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'monthGroups@52-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'monthGroups@53-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>
+  {
+    .field static assembly initonly class assembly/'monthGroups@53-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]> Invoke(class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> mg) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  call       !!0[] [System.Core]System.Linq.Enumerable::ToArray<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  newobj     instance void class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>::.ctor(!0,
+                                                                                                                 !1)
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'monthGroups@53-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'monthGroups@53-4' assembly/'monthGroups@53-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'yearGroups@48-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'yearGroups@48-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> _arg3) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>> V_1,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  stloc.2
+      IL_0008:  ldloc.2
+      IL_0009:  ldloc.2
+      IL_000a:  ldloc.2
+      IL_000b:  ldloc.2
+      IL_000c:  ldloc.2
+      IL_000d:  ldloc.0
+      IL_000e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0013:  ldloc.2
+      IL_0014:  newobj     instance void assembly/monthGroups@51::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+      IL_0019:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Order,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_001e:  ldsfld     class assembly/'monthGroups@52-1' assembly/'monthGroups@52-1'::@_instance
+      IL_0023:  ldsfld     class assembly/'monthGroups@52-2' assembly/'monthGroups@52-2'::@_instance
+      IL_0028:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Order,int32,class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+      IL_002d:  ldloc.2
+      IL_002e:  newobj     instance void assembly/'monthGroups@52-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+      IL_0033:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_0038:  ldsfld     class assembly/'monthGroups@53-4' assembly/'monthGroups@53-4'::@_instance
+      IL_003d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_0042:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_0047:  stloc.1
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'yearGroups@48-3'::builder@
+      IL_004e:  ldloc.0
+      IL_004f:  ldloc.1
+      IL_0050:  newobj     instance void class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>::.ctor(!0,
+                                                                                                                                                                                                                                                                                      !1)
+      IL_0055:  tail.
+      IL_0057:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object>(!!0)
+      IL_005c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'yearGroups@55-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>
+  {
+    .field static assembly initonly class assembly/'yearGroups@55-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]> Invoke(class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>> V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  call       !!0[] [System.Core]System.Linq.Enumerable::ToArray<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_001a:  newobj     instance void class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>::.ctor(!0,
+                                                                                                                                                         !1)
+      IL_001f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'yearGroups@55-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'yearGroups@55-4' assembly/'yearGroups@55-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 43@44'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 43@44'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>> V_1,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  stloc.2
+      IL_0008:  ldloc.2
+      IL_0009:  ldloc.2
+      IL_000a:  ldloc.2
+      IL_000b:  ldloc.2
+      IL_000c:  ldloc.2
+      IL_000d:  ldloc.0
+      IL_000e:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0013:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0018:  ldloc.2
+      IL_0019:  newobj     instance void assembly/yearGroups@47::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+      IL_001e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Order,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_0023:  ldsfld     class assembly/'yearGroups@48-1' assembly/'yearGroups@48-1'::@_instance
+      IL_0028:  ldsfld     class assembly/'yearGroups@48-2' assembly/'yearGroups@48-2'::@_instance
+      IL_002d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Order,int32,class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+      IL_0032:  ldloc.2
+      IL_0033:  newobj     instance void assembly/'yearGroups@48-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+      IL_0038:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_003d:  ldsfld     class assembly/'yearGroups@55-4' assembly/'yearGroups@55-4'::@_instance
+      IL_0042:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Core]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_0047:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 43@44'::builder@
+      IL_0053:  ldloc.0
+      IL_0054:  ldloc.1
+      IL_0055:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>::.ctor(!0,
+                                                                                                                                                                                                                                                                               !1)
+      IL_005a:  tail.
+      IL_005c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object>(!!0)
+      IL_0061:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 43@57-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 43@57-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>> V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CompanyName()
+      IL_0014:  ldloc.1
+      IL_0015:  call       !!0[] [System.Core]System.Linq.Enumerable::ToArray<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_001a:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>::.ctor(!0,
+                                                                                                                                                                                                  !1)
+      IL_001f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 43@57-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 43@57-1' assembly/'Pipe #4 input at line 43@57-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> digits@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<int32,int32[]>[] numberGroups@12
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@20
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<char,string[]>[] wordGroups@22
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@30
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] orderGroups@32
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@40
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] customerOrderGroups@42
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_digits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@7
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<int32,int32[]>[] get_numberGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<int32,int32[]>[] assembly::numberGroups@12
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@20
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<char,string[]>[] get_wordGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<char,string[]>[] assembly::wordGroups@22
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@30
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] get_orderGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] assembly::orderGroups@32
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@40
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] get_customerOrderGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] assembly::customerOrderGroups@42
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,int32[]>> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<char,string[]>> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7)
+    IL_0000:  ldstr      "zero"
+    IL_0005:  ldstr      "one"
+    IL_000a:  ldstr      "two"
+    IL_000f:  ldstr      "three"
+    IL_0014:  ldstr      "four"
+    IL_0019:  ldstr      "five"
+    IL_001e:  ldstr      "six"
+    IL_0023:  ldstr      "seven"
+    IL_0028:  ldstr      "eight"
+    IL_002d:  ldstr      "nine"
+    IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0037:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_003c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0041:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0046:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_004b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0050:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0055:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_005a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_005f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0064:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0069:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@7
+    IL_006e:  ldc.i4.5
+    IL_006f:  ldc.i4.4
+    IL_0070:  ldc.i4.1
+    IL_0071:  ldc.i4.3
+    IL_0072:  ldc.i4.s   9
+    IL_0074:  ldc.i4.8
+    IL_0075:  ldc.i4.6
+    IL_0076:  ldc.i4.7
+    IL_0077:  ldc.i4.2
+    IL_0078:  ldc.i4.0
+    IL_0079:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_007e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0083:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0088:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_008d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0092:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0097:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_009c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00a1:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00a6:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00ab:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00b0:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@10
+    IL_00b5:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00ba:  stloc.1
+    IL_00bb:  ldloc.1
+    IL_00bc:  ldloc.1
+    IL_00bd:  ldloc.1
+    IL_00be:  ldloc.1
+    IL_00bf:  ldloc.1
+    IL_00c0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+    IL_00c5:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00ca:  ldloc.1
+    IL_00cb:  newobj     instance void assembly/'Pipe #1 input at line 13@14'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00d0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,int32,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00d5:  ldsfld     class assembly/'Pipe #1 input at line 13@15-1' assembly/'Pipe #1 input at line 13@15-1'::@_instance
+    IL_00da:  ldsfld     class assembly/'Pipe #1 input at line 13@15-2' assembly/'Pipe #1 input at line 13@15-2'::@_instance
+    IL_00df:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<int32,int32,int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_00e4:  ldloc.1
+    IL_00e5:  newobj     instance void assembly/'Pipe #1 input at line 13@15-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00ea:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<int32,int32>,class [runtime]System.Collections.IEnumerable,class [System.Core]System.Linq.IGrouping`2<int32,int32>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00ef:  ldsfld     class assembly/'Pipe #1 input at line 13@16-4' assembly/'Pipe #1 input at line 13@16-4'::@_instance
+    IL_00f4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Core]System.Linq.IGrouping`2<int32,int32>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,int32[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00f9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00fe:  stloc.0
+    IL_00ff:  ldloc.0
+    IL_0100:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<int32,int32[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0105:  stsfld     class [runtime]System.Tuple`2<int32,int32[]>[] assembly::numberGroups@12
+    IL_010a:  ldstr      "blueberry"
+    IL_010f:  ldstr      "chimpanzee"
+    IL_0114:  ldstr      "abacus"
+    IL_0119:  ldstr      "banana"
+    IL_011e:  ldstr      "apple"
+    IL_0123:  ldstr      "cheese"
+    IL_0128:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_012d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0132:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0137:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_013c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0141:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0146:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_014b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@20
+    IL_0150:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0155:  stloc.3
+    IL_0156:  ldloc.3
+    IL_0157:  ldloc.3
+    IL_0158:  ldloc.3
+    IL_0159:  ldloc.3
+    IL_015a:  ldloc.3
+    IL_015b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+    IL_0160:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0165:  ldloc.3
+    IL_0166:  newobj     instance void assembly/'Pipe #2 input at line 23@24'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_016b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<string,class [runtime]System.Collections.IEnumerable,string,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0170:  ldsfld     class assembly/'Pipe #2 input at line 23@25-1' assembly/'Pipe #2 input at line 23@25-1'::@_instance
+    IL_0175:  ldsfld     class assembly/'Pipe #2 input at line 23@25-2' assembly/'Pipe #2 input at line 23@25-2'::@_instance
+    IL_017a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<string,char,string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_017f:  ldloc.3
+    IL_0180:  newobj     instance void assembly/'Pipe #2 input at line 23@25-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0185:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<char,string>,class [runtime]System.Collections.IEnumerable,class [System.Core]System.Linq.IGrouping`2<char,string>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_018a:  ldsfld     class assembly/'Pipe #2 input at line 23@26-4' assembly/'Pipe #2 input at line 23@26-4'::@_instance
+    IL_018f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Core]System.Linq.IGrouping`2<char,string>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<char,string[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0194:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<char,string[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0199:  stloc.2
+    IL_019a:  ldloc.2
+    IL_019b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<char,string[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01a0:  stsfld     class [runtime]System.Tuple`2<char,string[]>[] assembly::wordGroups@22
+    IL_01a5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_01aa:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@30
+    IL_01af:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_01b4:  stloc.s    V_5
+    IL_01b6:  ldloc.s    V_5
+    IL_01b8:  ldloc.s    V_5
+    IL_01ba:  ldloc.s    V_5
+    IL_01bc:  ldloc.s    V_5
+    IL_01be:  ldloc.s    V_5
+    IL_01c0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_01c5:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01ca:  ldloc.s    V_5
+    IL_01cc:  newobj     instance void assembly/'Pipe #3 input at line 33@34'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01d1:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01d6:  ldsfld     class assembly/'Pipe #3 input at line 33@35-1' assembly/'Pipe #3 input at line 33@35-1'::@_instance
+    IL_01db:  ldsfld     class assembly/'Pipe #3 input at line 33@35-2' assembly/'Pipe #3 input at line 33@35-2'::@_instance
+    IL_01e0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_01e5:  ldloc.s    V_5
+    IL_01e7:  newobj     instance void assembly/'Pipe #3 input at line 33@35-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01ec:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01f1:  ldsfld     class assembly/'Pipe #3 input at line 33@36-4' assembly/'Pipe #3 input at line 33@36-4'::@_instance
+    IL_01f6:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01fb:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0200:  stloc.s    V_4
+    IL_0202:  ldloc.s    V_4
+    IL_0204:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0209:  stsfld     class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] assembly::orderGroups@32
+    IL_020e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_0213:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@40
+    IL_0218:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_021d:  stloc.s    V_7
+    IL_021f:  ldloc.s    V_7
+    IL_0221:  ldloc.s    V_7
+    IL_0223:  ldloc.s    V_7
+    IL_0225:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_022a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_022f:  ldloc.s    V_7
+    IL_0231:  newobj     instance void assembly/'Pipe #4 input at line 43@44'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0236:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_023b:  ldsfld     class assembly/'Pipe #4 input at line 43@57-1' assembly/'Pipe #4 input at line 43@57-1'::@_instance
+    IL_0240:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0245:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_024a:  stloc.s    V_6
+    IL_024c:  ldloc.s    V_6
+    IL_024e:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0253:  stsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] assembly::customerOrderGroups@42
+    IL_0258:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          digits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property class [runtime]System.Tuple`2<int32,int32[]>[]
+          numberGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<int32,int32[]>[] assembly::get_numberGroups()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property class [runtime]System.Tuple`2<char,string[]>[]
+          wordGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<char,string[]>[] assembly::get_wordGroups()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[]
+          orderGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] assembly::get_orderGroups()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[]
+          customerOrderGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] assembly::get_customerOrderGroups()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOn.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
new file mode 100644
index 00000000000..f1572eba9b3
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
@@ -0,0 +1,1540 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern System.Linq
+{
+  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         
+  .ver 8:0:0:0
+}
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@14'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@14'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@14'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<int32,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@15-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@15-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@15-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@15-1' assembly/'Pipe #1 input at line 13@15-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@15-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@15-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.5
+      IL_0002:  rem
+      IL_0003:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@15-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@15-2' assembly/'Pipe #1 input at line 13@15-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@15-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@15-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<int32,int32> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<int32,int32> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@15-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@16-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,class [runtime]System.Tuple`2<int32,int32[]>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@16-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,class [runtime]System.Tuple`2<int32,int32[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,int32[]> Invoke(class [System.Linq]System.Linq.IGrouping`2<int32,int32> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<int32,int32>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  call       !!0[] [System.Linq]System.Linq.Enumerable::ToArray<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  newobj     instance void class [runtime]System.Tuple`2<int32,int32[]>::.ctor(!0,
+                                                                                                    !1)
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@16-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@16-4' assembly/'Pipe #1 input at line 13@16-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@24'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 23@24'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,object> Invoke(string _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 23@24'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<string,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@25-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 23@25-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 23@25-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 23@25-1' assembly/'Pipe #2 input at line 23@25-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@25-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,char>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 23@25-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,char>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance char Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.0
+      IL_0002:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 23@25-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 23@25-2' assembly/'Pipe #2 input at line 23@25-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@25-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<char,string>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<char,string>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<char,string>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<char,string>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 23@25-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<char,string>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<char,string> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<char,string> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 23@25-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Linq]System.Linq.IGrouping`2<char,string>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@26-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<char,string>,class [runtime]System.Tuple`2<char,string[]>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 23@26-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<char,string>,class [runtime]System.Tuple`2<char,string[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<char,string[]> Invoke(class [System.Linq]System.Linq.IGrouping`2<char,string> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<char,string>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  call       !!0[] [System.Linq]System.Linq.Enumerable::ToArray<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  newobj     instance void class [runtime]System.Tuple`2<char,string[]>::.ctor(!0,
+                                                                                                    !1)
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 23@26-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 23@26-4' assembly/'Pipe #2 input at line 23@26-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@34'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 33@34'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 33@34'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@35-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 33@35-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 33@35-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 33@35-1' assembly/'Pipe #3 input at line 33@35-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@35-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 33@35-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 33@35-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 33@35-2' assembly/'Pipe #3 input at line 33@35-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@35-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 33@35-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 33@35-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@36-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 33@36-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  call       !!0[] [System.Linq]System.Linq.Enumerable::ToArray<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  newobj     instance void class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>::.ctor(!0,
+                                                                                                                          !1)
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 33@36-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 33@36-4' assembly/'Pipe #3 input at line 33@36-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit yearGroups@47
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/yearGroups@47::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/yearGroups@47::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Order,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'yearGroups@48-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [Utils]Utils/Order>
+  {
+    .field static assembly initonly class assembly/'yearGroups@48-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [Utils]Utils/Order>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Order Invoke(class [Utils]Utils/Order o) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'yearGroups@48-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'yearGroups@48-1' assembly/'yearGroups@48-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'yearGroups@48-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,int32>
+  {
+    .field static assembly initonly class assembly/'yearGroups@48-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class [Utils]Utils/Order o) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (valuetype [runtime]System.DateTime V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  call       instance int32 [runtime]System.DateTime::get_Year()
+      IL_000e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'yearGroups@48-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'yearGroups@48-2' assembly/'yearGroups@48-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit monthGroups@51
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/monthGroups@51::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object> Invoke(class [Utils]Utils/Order _arg4) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/monthGroups@51::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Order,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'monthGroups@52-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [Utils]Utils/Order>
+  {
+    .field static assembly initonly class assembly/'monthGroups@52-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [Utils]Utils/Order>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Order Invoke(class [Utils]Utils/Order o) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'monthGroups@52-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'monthGroups@52-1' assembly/'monthGroups@52-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'monthGroups@52-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,int32>
+  {
+    .field static assembly initonly class assembly/'monthGroups@52-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class [Utils]Utils/Order o) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (valuetype [runtime]System.DateTime V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  call       instance int32 [runtime]System.DateTime::get_Month()
+      IL_000e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'monthGroups@52-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'monthGroups@52-2' assembly/'monthGroups@52-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'monthGroups@52-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'monthGroups@52-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> _arg5) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'monthGroups@52-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'monthGroups@53-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>
+  {
+    .field static assembly initonly class assembly/'monthGroups@53-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]> Invoke(class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> mg) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  call       !!0[] [System.Linq]System.Linq.Enumerable::ToArray<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  newobj     instance void class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>::.ctor(!0,
+                                                                                                                       !1)
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'monthGroups@53-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'monthGroups@53-4' assembly/'monthGroups@53-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'yearGroups@48-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'yearGroups@48-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> _arg3) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>> V_1,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  stloc.2
+      IL_0008:  ldloc.2
+      IL_0009:  ldloc.2
+      IL_000a:  ldloc.2
+      IL_000b:  ldloc.2
+      IL_000c:  ldloc.2
+      IL_000d:  ldloc.0
+      IL_000e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0013:  ldloc.2
+      IL_0014:  newobj     instance void assembly/monthGroups@51::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+      IL_0019:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Order,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_001e:  ldsfld     class assembly/'monthGroups@52-1' assembly/'monthGroups@52-1'::@_instance
+      IL_0023:  ldsfld     class assembly/'monthGroups@52-2' assembly/'monthGroups@52-2'::@_instance
+      IL_0028:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Order,int32,class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+      IL_002d:  ldloc.2
+      IL_002e:  newobj     instance void assembly/'monthGroups@52-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+      IL_0033:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_0038:  ldsfld     class assembly/'monthGroups@53-4' assembly/'monthGroups@53-4'::@_instance
+      IL_003d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_0042:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_0047:  stloc.1
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'yearGroups@48-3'::builder@
+      IL_004e:  ldloc.0
+      IL_004f:  ldloc.1
+      IL_0050:  newobj     instance void class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>::.ctor(!0,
+                                                                                                                                                                                                                                                                                                        !1)
+      IL_0055:  tail.
+      IL_0057:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object>(!!0)
+      IL_005c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'yearGroups@55-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>
+  {
+    .field static assembly initonly class assembly/'yearGroups@55-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]> Invoke(class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>> V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  call       !!0[] [System.Linq]System.Linq.Enumerable::ToArray<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_001a:  newobj     instance void class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>::.ctor(!0,
+                                                                                                                                                                     !1)
+      IL_001f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'yearGroups@55-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'yearGroups@55-4' assembly/'yearGroups@55-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 43@44'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 43@44'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>> V_1,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  stloc.2
+      IL_0008:  ldloc.2
+      IL_0009:  ldloc.2
+      IL_000a:  ldloc.2
+      IL_000b:  ldloc.2
+      IL_000c:  ldloc.2
+      IL_000d:  ldloc.0
+      IL_000e:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0013:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0018:  ldloc.2
+      IL_0019:  newobj     instance void assembly/yearGroups@47::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+      IL_001e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Order,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_0023:  ldsfld     class assembly/'yearGroups@48-1' assembly/'yearGroups@48-1'::@_instance
+      IL_0028:  ldsfld     class assembly/'yearGroups@48-2' assembly/'yearGroups@48-2'::@_instance
+      IL_002d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Order,int32,class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+      IL_0032:  ldloc.2
+      IL_0033:  newobj     instance void assembly/'yearGroups@48-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+      IL_0038:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_003d:  ldsfld     class assembly/'yearGroups@55-4' assembly/'yearGroups@55-4'::@_instance
+      IL_0042:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_0047:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 43@44'::builder@
+      IL_0053:  ldloc.0
+      IL_0054:  ldloc.1
+      IL_0055:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>::.ctor(!0,
+                                                                                                                                                                                                                                                                                                       !1)
+      IL_005a:  tail.
+      IL_005c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object>(!!0)
+      IL_0061:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 43@57-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 43@57-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>> V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CompanyName()
+      IL_0014:  ldloc.1
+      IL_0015:  call       !!0[] [System.Linq]System.Linq.Enumerable::ToArray<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_001a:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>::.ctor(!0,
+                                                                                                                                                                                                                    !1)
+      IL_001f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 43@57-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 43@57-1' assembly/'Pipe #4 input at line 43@57-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> digits@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<int32,int32[]>[] numberGroups@12
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@20
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<char,string[]>[] wordGroups@22
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@30
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] orderGroups@32
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@40
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] customerOrderGroups@42
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_digits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@7
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<int32,int32[]>[] get_numberGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<int32,int32[]>[] assembly::numberGroups@12
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@20
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<char,string[]>[] get_wordGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<char,string[]>[] assembly::wordGroups@22
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@30
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] get_orderGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] assembly::orderGroups@32
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@40
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] get_customerOrderGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] assembly::customerOrderGroups@42
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,int32[]>> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<char,string[]>> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7)
+    IL_0000:  ldstr      "zero"
+    IL_0005:  ldstr      "one"
+    IL_000a:  ldstr      "two"
+    IL_000f:  ldstr      "three"
+    IL_0014:  ldstr      "four"
+    IL_0019:  ldstr      "five"
+    IL_001e:  ldstr      "six"
+    IL_0023:  ldstr      "seven"
+    IL_0028:  ldstr      "eight"
+    IL_002d:  ldstr      "nine"
+    IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0037:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_003c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0041:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0046:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_004b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0050:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0055:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_005a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_005f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0064:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0069:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@7
+    IL_006e:  ldc.i4.5
+    IL_006f:  ldc.i4.4
+    IL_0070:  ldc.i4.1
+    IL_0071:  ldc.i4.3
+    IL_0072:  ldc.i4.s   9
+    IL_0074:  ldc.i4.8
+    IL_0075:  ldc.i4.6
+    IL_0076:  ldc.i4.7
+    IL_0077:  ldc.i4.2
+    IL_0078:  ldc.i4.0
+    IL_0079:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_007e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0083:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0088:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_008d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0092:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0097:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_009c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00a1:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00a6:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00ab:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00b0:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@10
+    IL_00b5:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00ba:  stloc.1
+    IL_00bb:  ldloc.1
+    IL_00bc:  ldloc.1
+    IL_00bd:  ldloc.1
+    IL_00be:  ldloc.1
+    IL_00bf:  ldloc.1
+    IL_00c0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+    IL_00c5:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00ca:  ldloc.1
+    IL_00cb:  newobj     instance void assembly/'Pipe #1 input at line 13@14'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00d0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,int32,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00d5:  ldsfld     class assembly/'Pipe #1 input at line 13@15-1' assembly/'Pipe #1 input at line 13@15-1'::@_instance
+    IL_00da:  ldsfld     class assembly/'Pipe #1 input at line 13@15-2' assembly/'Pipe #1 input at line 13@15-2'::@_instance
+    IL_00df:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<int32,int32,int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_00e4:  ldloc.1
+    IL_00e5:  newobj     instance void assembly/'Pipe #1 input at line 13@15-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00ea:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,class [runtime]System.Collections.IEnumerable,class [System.Linq]System.Linq.IGrouping`2<int32,int32>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00ef:  ldsfld     class assembly/'Pipe #1 input at line 13@16-4' assembly/'Pipe #1 input at line 13@16-4'::@_instance
+    IL_00f4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,int32[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00f9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00fe:  stloc.0
+    IL_00ff:  ldloc.0
+    IL_0100:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<int32,int32[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0105:  stsfld     class [runtime]System.Tuple`2<int32,int32[]>[] assembly::numberGroups@12
+    IL_010a:  ldstr      "blueberry"
+    IL_010f:  ldstr      "chimpanzee"
+    IL_0114:  ldstr      "abacus"
+    IL_0119:  ldstr      "banana"
+    IL_011e:  ldstr      "apple"
+    IL_0123:  ldstr      "cheese"
+    IL_0128:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_012d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0132:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0137:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_013c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0141:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0146:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_014b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@20
+    IL_0150:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0155:  stloc.3
+    IL_0156:  ldloc.3
+    IL_0157:  ldloc.3
+    IL_0158:  ldloc.3
+    IL_0159:  ldloc.3
+    IL_015a:  ldloc.3
+    IL_015b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+    IL_0160:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0165:  ldloc.3
+    IL_0166:  newobj     instance void assembly/'Pipe #2 input at line 23@24'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_016b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<string,class [runtime]System.Collections.IEnumerable,string,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0170:  ldsfld     class assembly/'Pipe #2 input at line 23@25-1' assembly/'Pipe #2 input at line 23@25-1'::@_instance
+    IL_0175:  ldsfld     class assembly/'Pipe #2 input at line 23@25-2' assembly/'Pipe #2 input at line 23@25-2'::@_instance
+    IL_017a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<string,char,string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_017f:  ldloc.3
+    IL_0180:  newobj     instance void assembly/'Pipe #2 input at line 23@25-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0185:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<char,string>,class [runtime]System.Collections.IEnumerable,class [System.Linq]System.Linq.IGrouping`2<char,string>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_018a:  ldsfld     class assembly/'Pipe #2 input at line 23@26-4' assembly/'Pipe #2 input at line 23@26-4'::@_instance
+    IL_018f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Linq]System.Linq.IGrouping`2<char,string>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<char,string[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0194:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<char,string[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0199:  stloc.2
+    IL_019a:  ldloc.2
+    IL_019b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<char,string[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01a0:  stsfld     class [runtime]System.Tuple`2<char,string[]>[] assembly::wordGroups@22
+    IL_01a5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_01aa:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@30
+    IL_01af:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_01b4:  stloc.s    V_5
+    IL_01b6:  ldloc.s    V_5
+    IL_01b8:  ldloc.s    V_5
+    IL_01ba:  ldloc.s    V_5
+    IL_01bc:  ldloc.s    V_5
+    IL_01be:  ldloc.s    V_5
+    IL_01c0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_01c5:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01ca:  ldloc.s    V_5
+    IL_01cc:  newobj     instance void assembly/'Pipe #3 input at line 33@34'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01d1:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01d6:  ldsfld     class assembly/'Pipe #3 input at line 33@35-1' assembly/'Pipe #3 input at line 33@35-1'::@_instance
+    IL_01db:  ldsfld     class assembly/'Pipe #3 input at line 33@35-2' assembly/'Pipe #3 input at line 33@35-2'::@_instance
+    IL_01e0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_01e5:  ldloc.s    V_5
+    IL_01e7:  newobj     instance void assembly/'Pipe #3 input at line 33@35-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01ec:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01f1:  ldsfld     class assembly/'Pipe #3 input at line 33@36-4' assembly/'Pipe #3 input at line 33@36-4'::@_instance
+    IL_01f6:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01fb:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0200:  stloc.s    V_4
+    IL_0202:  ldloc.s    V_4
+    IL_0204:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0209:  stsfld     class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] assembly::orderGroups@32
+    IL_020e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_0213:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@40
+    IL_0218:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_021d:  stloc.s    V_7
+    IL_021f:  ldloc.s    V_7
+    IL_0221:  ldloc.s    V_7
+    IL_0223:  ldloc.s    V_7
+    IL_0225:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_022a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_022f:  ldloc.s    V_7
+    IL_0231:  newobj     instance void assembly/'Pipe #4 input at line 43@44'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0236:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_023b:  ldsfld     class assembly/'Pipe #4 input at line 43@57-1' assembly/'Pipe #4 input at line 43@57-1'::@_instance
+    IL_0240:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0245:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_024a:  stloc.s    V_6
+    IL_024c:  ldloc.s    V_6
+    IL_024e:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0253:  stsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] assembly::customerOrderGroups@42
+    IL_0258:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          digits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property class [runtime]System.Tuple`2<int32,int32[]>[]
+          numberGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<int32,int32[]>[] assembly::get_numberGroups()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property class [runtime]System.Tuple`2<char,string[]>[]
+          wordGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<char,string[]>[] assembly::get_wordGroups()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[]
+          orderGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] assembly::get_orderGroups()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[]
+          customerOrderGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] assembly::get_customerOrderGroups()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOn.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOn.il.netcore.release.bsl
new file mode 100644
index 00000000000..f1572eba9b3
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Grouping01.fs.RealInternalSignatureOn.il.netcore.release.bsl
@@ -0,0 +1,1540 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern System.Linq
+{
+  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         
+  .ver 8:0:0:0
+}
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@14'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@14'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@14'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<int32,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@15-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@15-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@15-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@15-1' assembly/'Pipe #1 input at line 13@15-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@15-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@15-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.5
+      IL_0002:  rem
+      IL_0003:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@15-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@15-2' assembly/'Pipe #1 input at line 13@15-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@15-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@15-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<int32,int32> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<int32,int32> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@15-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@16-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,class [runtime]System.Tuple`2<int32,int32[]>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@16-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,class [runtime]System.Tuple`2<int32,int32[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,int32[]> Invoke(class [System.Linq]System.Linq.IGrouping`2<int32,int32> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<int32,int32>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  call       !!0[] [System.Linq]System.Linq.Enumerable::ToArray<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  newobj     instance void class [runtime]System.Tuple`2<int32,int32[]>::.ctor(!0,
+                                                                                                    !1)
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@16-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@16-4' assembly/'Pipe #1 input at line 13@16-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@24'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 23@24'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,object> Invoke(string _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 23@24'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<string,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@25-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 23@25-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 23@25-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 23@25-1' assembly/'Pipe #2 input at line 23@25-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@25-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,char>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 23@25-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,char>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance char Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.0
+      IL_0002:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 23@25-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 23@25-2' assembly/'Pipe #2 input at line 23@25-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@25-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<char,string>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<char,string>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<char,string>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<char,string>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 23@25-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<char,string>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<char,string> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<char,string> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 23@25-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Linq]System.Linq.IGrouping`2<char,string>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 23@26-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<char,string>,class [runtime]System.Tuple`2<char,string[]>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 23@26-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<char,string>,class [runtime]System.Tuple`2<char,string[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<char,string[]> Invoke(class [System.Linq]System.Linq.IGrouping`2<char,string> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<char,string>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  call       !!0[] [System.Linq]System.Linq.Enumerable::ToArray<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  newobj     instance void class [runtime]System.Tuple`2<char,string[]>::.ctor(!0,
+                                                                                                    !1)
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 23@26-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 23@26-4' assembly/'Pipe #2 input at line 23@26-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@34'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 33@34'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 33@34'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@35-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 33@35-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 33@35-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 33@35-1' assembly/'Pipe #3 input at line 33@35-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@35-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 33@35-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 33@35-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 33@35-2' assembly/'Pipe #3 input at line 33@35-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@35-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 33@35-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 33@35-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 33@36-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 33@36-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  call       !!0[] [System.Linq]System.Linq.Enumerable::ToArray<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  newobj     instance void class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>::.ctor(!0,
+                                                                                                                          !1)
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 33@36-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 33@36-4' assembly/'Pipe #3 input at line 33@36-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit yearGroups@47
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/yearGroups@47::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/yearGroups@47::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Order,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'yearGroups@48-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [Utils]Utils/Order>
+  {
+    .field static assembly initonly class assembly/'yearGroups@48-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [Utils]Utils/Order>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Order Invoke(class [Utils]Utils/Order o) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'yearGroups@48-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'yearGroups@48-1' assembly/'yearGroups@48-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'yearGroups@48-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,int32>
+  {
+    .field static assembly initonly class assembly/'yearGroups@48-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class [Utils]Utils/Order o) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (valuetype [runtime]System.DateTime V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  call       instance int32 [runtime]System.DateTime::get_Year()
+      IL_000e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'yearGroups@48-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'yearGroups@48-2' assembly/'yearGroups@48-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit monthGroups@51
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/monthGroups@51::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Order,object> Invoke(class [Utils]Utils/Order _arg4) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/monthGroups@51::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Order,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'monthGroups@52-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [Utils]Utils/Order>
+  {
+    .field static assembly initonly class assembly/'monthGroups@52-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [Utils]Utils/Order>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Order Invoke(class [Utils]Utils/Order o) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'monthGroups@52-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'monthGroups@52-1' assembly/'monthGroups@52-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'monthGroups@52-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,int32>
+  {
+    .field static assembly initonly class assembly/'monthGroups@52-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class [Utils]Utils/Order o) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (valuetype [runtime]System.DateTime V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  call       instance int32 [runtime]System.DateTime::get_Month()
+      IL_000e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'monthGroups@52-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'monthGroups@52-2' assembly/'monthGroups@52-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'monthGroups@52-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'monthGroups@52-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> _arg5) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'monthGroups@52-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'monthGroups@53-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>
+  {
+    .field static assembly initonly class assembly/'monthGroups@53-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]> Invoke(class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> mg) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  call       !!0[] [System.Linq]System.Linq.Enumerable::ToArray<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  newobj     instance void class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>::.ctor(!0,
+                                                                                                                       !1)
+      IL_0011:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'monthGroups@53-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'monthGroups@53-4' assembly/'monthGroups@53-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'yearGroups@48-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'yearGroups@48-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> _arg3) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>> V_1,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  stloc.2
+      IL_0008:  ldloc.2
+      IL_0009:  ldloc.2
+      IL_000a:  ldloc.2
+      IL_000b:  ldloc.2
+      IL_000c:  ldloc.2
+      IL_000d:  ldloc.0
+      IL_000e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0013:  ldloc.2
+      IL_0014:  newobj     instance void assembly/monthGroups@51::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+      IL_0019:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Order,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_001e:  ldsfld     class assembly/'monthGroups@52-1' assembly/'monthGroups@52-1'::@_instance
+      IL_0023:  ldsfld     class assembly/'monthGroups@52-2' assembly/'monthGroups@52-2'::@_instance
+      IL_0028:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Order,int32,class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+      IL_002d:  ldloc.2
+      IL_002e:  newobj     instance void assembly/'monthGroups@52-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+      IL_0033:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_0038:  ldsfld     class assembly/'monthGroups@53-4' assembly/'monthGroups@53-4'::@_instance
+      IL_003d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_0042:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_0047:  stloc.1
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'yearGroups@48-3'::builder@
+      IL_004e:  ldloc.0
+      IL_004f:  ldloc.1
+      IL_0050:  newobj     instance void class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>::.ctor(!0,
+                                                                                                                                                                                                                                                                                                        !1)
+      IL_0055:  tail.
+      IL_0057:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object>(!!0)
+      IL_005c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'yearGroups@55-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>
+  {
+    .field static assembly initonly class assembly/'yearGroups@55-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]> Invoke(class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>> V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>::get_Key()
+      IL_0014:  ldloc.1
+      IL_0015:  call       !!0[] [System.Linq]System.Linq.Enumerable::ToArray<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_001a:  newobj     instance void class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>::.ctor(!0,
+                                                                                                                                                                     !1)
+      IL_001f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'yearGroups@55-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'yearGroups@55-4' assembly/'yearGroups@55-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 43@44'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 43@44'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>> V_1,
+               class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+      IL_0007:  stloc.2
+      IL_0008:  ldloc.2
+      IL_0009:  ldloc.2
+      IL_000a:  ldloc.2
+      IL_000b:  ldloc.2
+      IL_000c:  ldloc.2
+      IL_000d:  ldloc.0
+      IL_000e:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0013:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0018:  ldloc.2
+      IL_0019:  newobj     instance void assembly/yearGroups@47::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+      IL_001e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Order,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_0023:  ldsfld     class assembly/'yearGroups@48-1' assembly/'yearGroups@48-1'::@_instance
+      IL_0028:  ldsfld     class assembly/'yearGroups@48-2' assembly/'yearGroups@48-2'::@_instance
+      IL_002d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Order,int32,class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+      IL_0032:  ldloc.2
+      IL_0033:  newobj     instance void assembly/'yearGroups@48-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+      IL_0038:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_003d:  ldsfld     class assembly/'yearGroups@55-4' assembly/'yearGroups@55-4'::@_instance
+      IL_0042:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [System.Linq]System.Linq.IGrouping`2<int32,class [Utils]Utils/Order>,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+      IL_0047:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 43@44'::builder@
+      IL_0053:  ldloc.0
+      IL_0054:  ldloc.1
+      IL_0055:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>::.ctor(!0,
+                                                                                                                                                                                                                                                                                                       !1)
+      IL_005a:  tail.
+      IL_005c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object>(!!0)
+      IL_0061:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 43@57-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 43@57-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>> V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CompanyName()
+      IL_0014:  ldloc.1
+      IL_0015:  call       !!0[] [System.Linq]System.Linq.Enumerable::ToArray<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_001a:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>::.ctor(!0,
+                                                                                                                                                                                                                    !1)
+      IL_001f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 43@57-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 43@57-1' assembly/'Pipe #4 input at line 43@57-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> digits@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<int32,int32[]>[] numberGroups@12
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@20
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<char,string[]>[] wordGroups@22
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@30
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] orderGroups@32
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@40
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] customerOrderGroups@42
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_digits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@7
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<int32,int32[]>[] get_numberGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<int32,int32[]>[] assembly::numberGroups@12
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@20
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<char,string[]>[] get_wordGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<char,string[]>[] assembly::wordGroups@22
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@30
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] get_orderGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] assembly::orderGroups@32
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@40
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] get_customerOrderGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] assembly::customerOrderGroups@42
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,int32[]>> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<char,string[]>> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7)
+    IL_0000:  ldstr      "zero"
+    IL_0005:  ldstr      "one"
+    IL_000a:  ldstr      "two"
+    IL_000f:  ldstr      "three"
+    IL_0014:  ldstr      "four"
+    IL_0019:  ldstr      "five"
+    IL_001e:  ldstr      "six"
+    IL_0023:  ldstr      "seven"
+    IL_0028:  ldstr      "eight"
+    IL_002d:  ldstr      "nine"
+    IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0037:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_003c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0041:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0046:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_004b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0050:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0055:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_005a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_005f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0064:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0069:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@7
+    IL_006e:  ldc.i4.5
+    IL_006f:  ldc.i4.4
+    IL_0070:  ldc.i4.1
+    IL_0071:  ldc.i4.3
+    IL_0072:  ldc.i4.s   9
+    IL_0074:  ldc.i4.8
+    IL_0075:  ldc.i4.6
+    IL_0076:  ldc.i4.7
+    IL_0077:  ldc.i4.2
+    IL_0078:  ldc.i4.0
+    IL_0079:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_007e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0083:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0088:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_008d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0092:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0097:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_009c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00a1:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00a6:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00ab:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00b0:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@10
+    IL_00b5:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00ba:  stloc.1
+    IL_00bb:  ldloc.1
+    IL_00bc:  ldloc.1
+    IL_00bd:  ldloc.1
+    IL_00be:  ldloc.1
+    IL_00bf:  ldloc.1
+    IL_00c0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+    IL_00c5:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00ca:  ldloc.1
+    IL_00cb:  newobj     instance void assembly/'Pipe #1 input at line 13@14'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00d0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,int32,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00d5:  ldsfld     class assembly/'Pipe #1 input at line 13@15-1' assembly/'Pipe #1 input at line 13@15-1'::@_instance
+    IL_00da:  ldsfld     class assembly/'Pipe #1 input at line 13@15-2' assembly/'Pipe #1 input at line 13@15-2'::@_instance
+    IL_00df:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<int32,int32,int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_00e4:  ldloc.1
+    IL_00e5:  newobj     instance void assembly/'Pipe #1 input at line 13@15-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00ea:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,class [runtime]System.Collections.IEnumerable,class [System.Linq]System.Linq.IGrouping`2<int32,int32>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00ef:  ldsfld     class assembly/'Pipe #1 input at line 13@16-4' assembly/'Pipe #1 input at line 13@16-4'::@_instance
+    IL_00f4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Linq]System.Linq.IGrouping`2<int32,int32>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,int32[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00f9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00fe:  stloc.0
+    IL_00ff:  ldloc.0
+    IL_0100:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<int32,int32[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0105:  stsfld     class [runtime]System.Tuple`2<int32,int32[]>[] assembly::numberGroups@12
+    IL_010a:  ldstr      "blueberry"
+    IL_010f:  ldstr      "chimpanzee"
+    IL_0114:  ldstr      "abacus"
+    IL_0119:  ldstr      "banana"
+    IL_011e:  ldstr      "apple"
+    IL_0123:  ldstr      "cheese"
+    IL_0128:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_012d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0132:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0137:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_013c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0141:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0146:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_014b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@20
+    IL_0150:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0155:  stloc.3
+    IL_0156:  ldloc.3
+    IL_0157:  ldloc.3
+    IL_0158:  ldloc.3
+    IL_0159:  ldloc.3
+    IL_015a:  ldloc.3
+    IL_015b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+    IL_0160:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0165:  ldloc.3
+    IL_0166:  newobj     instance void assembly/'Pipe #2 input at line 23@24'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_016b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<string,class [runtime]System.Collections.IEnumerable,string,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0170:  ldsfld     class assembly/'Pipe #2 input at line 23@25-1' assembly/'Pipe #2 input at line 23@25-1'::@_instance
+    IL_0175:  ldsfld     class assembly/'Pipe #2 input at line 23@25-2' assembly/'Pipe #2 input at line 23@25-2'::@_instance
+    IL_017a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<string,char,string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_017f:  ldloc.3
+    IL_0180:  newobj     instance void assembly/'Pipe #2 input at line 23@25-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0185:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<char,string>,class [runtime]System.Collections.IEnumerable,class [System.Linq]System.Linq.IGrouping`2<char,string>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_018a:  ldsfld     class assembly/'Pipe #2 input at line 23@26-4' assembly/'Pipe #2 input at line 23@26-4'::@_instance
+    IL_018f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Linq]System.Linq.IGrouping`2<char,string>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<char,string[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0194:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<char,string[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0199:  stloc.2
+    IL_019a:  ldloc.2
+    IL_019b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<char,string[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01a0:  stsfld     class [runtime]System.Tuple`2<char,string[]>[] assembly::wordGroups@22
+    IL_01a5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_01aa:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@30
+    IL_01af:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_01b4:  stloc.s    V_5
+    IL_01b6:  ldloc.s    V_5
+    IL_01b8:  ldloc.s    V_5
+    IL_01ba:  ldloc.s    V_5
+    IL_01bc:  ldloc.s    V_5
+    IL_01be:  ldloc.s    V_5
+    IL_01c0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_01c5:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01ca:  ldloc.s    V_5
+    IL_01cc:  newobj     instance void assembly/'Pipe #3 input at line 33@34'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01d1:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01d6:  ldsfld     class assembly/'Pipe #3 input at line 33@35-1' assembly/'Pipe #3 input at line 33@35-1'::@_instance
+    IL_01db:  ldsfld     class assembly/'Pipe #3 input at line 33@35-2' assembly/'Pipe #3 input at line 33@35-2'::@_instance
+    IL_01e0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_01e5:  ldloc.s    V_5
+    IL_01e7:  newobj     instance void assembly/'Pipe #3 input at line 33@35-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01ec:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01f1:  ldsfld     class assembly/'Pipe #3 input at line 33@36-4' assembly/'Pipe #3 input at line 33@36-4'::@_instance
+    IL_01f6:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01fb:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0200:  stloc.s    V_4
+    IL_0202:  ldloc.s    V_4
+    IL_0204:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0209:  stsfld     class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] assembly::orderGroups@32
+    IL_020e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_0213:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@40
+    IL_0218:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_021d:  stloc.s    V_7
+    IL_021f:  ldloc.s    V_7
+    IL_0221:  ldloc.s    V_7
+    IL_0223:  ldloc.s    V_7
+    IL_0225:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_022a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_022f:  ldloc.s    V_7
+    IL_0231:  newobj     instance void assembly/'Pipe #4 input at line 43@44'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0236:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_023b:  ldsfld     class assembly/'Pipe #4 input at line 43@57-1' assembly/'Pipe #4 input at line 43@57-1'::@_instance
+    IL_0240:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0245:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_024a:  stloc.s    V_6
+    IL_024c:  ldloc.s    V_6
+    IL_024e:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0253:  stsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] assembly::customerOrderGroups@42
+    IL_0258:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          digits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property class [runtime]System.Tuple`2<int32,int32[]>[]
+          numberGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<int32,int32[]>[] assembly::get_numberGroups()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property class [runtime]System.Tuple`2<char,string[]>[]
+          wordGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<char,string[]>[] assembly::get_wordGroups()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[]
+          orderGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [Utils]Utils/Product[]>[] assembly::get_orderGroups()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[]
+          customerOrderGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [runtime]System.Tuple`2<int32,class [runtime]System.Tuple`2<int32,class [Utils]Utils/Order[]>[]>[]>[] assembly::get_customerOrderGroups()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOff.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOff.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOff.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOff.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOff.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOff.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOn.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOn.il.net472.debug.bsl
new file mode 100644
index 00000000000..2851858eb06
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOn.il.net472.debug.bsl
@@ -0,0 +1,1318 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern System.Core
+{
+  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         
+  .ver 4:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@14'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 12@14' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 12@14'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 12@14' assembly/'Pipe #1 input at line 12@14'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@14-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 12@14-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 12@14-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 12@14-1' assembly/'Pipe #1 input at line 12@14-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@14-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [Utils]Utils/Product,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 12@14-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [Utils]Utils/Product,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [Utils]Utils/Product> 
+            Invoke(string c,
+                   class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  newobj     instance void class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::.ctor(!0,
+                                                                                                                  !1)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 12@14-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 12@14-2' assembly/'Pipe #1 input at line 12@14-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@14-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 12@14-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object> Invoke(class [runtime]System.Tuple`2<string,class [Utils]Utils/Product> _arg1) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [runtime]System.Tuple`2<string,class [Utils]Utils/Product> V_0,
+               class [Utils]Utils/Product V_1,
+               string V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance !1 class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::get_Item2()
+      IL_0008:  stloc.1
+      IL_0009:  ldloc.0
+      IL_000a:  call       instance !0 class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::get_Item1()
+      IL_000f:  stloc.2
+      IL_0010:  ldarg.0
+      IL_0011:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 12@14-3'::builder@
+      IL_0016:  ldloc.2
+      IL_0017:  ldloc.1
+      IL_0018:  newobj     instance void class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::.ctor(!0,
+                                                                                                                  !1)
+      IL_001d:  tail.
+      IL_001f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object>(!!0)
+      IL_0024:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@15-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 12@15-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,string> Invoke(class [runtime]System.Tuple`2<string,class [Utils]Utils/Product> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,string>::.ctor(!0,
+                                                                                              !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 12@15-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 12@15-4' assembly/'Pipe #1 input at line 12@15-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@22'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 20@22' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 20@22'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 20@22' assembly/'Pipe #2 input at line 20@22'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@22-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 20@22-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 20@22-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 20@22-1' assembly/'Pipe #2 input at line 20@22-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@22-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 20@22-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> 
+            Invoke(string c,
+                   class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                            !1)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 20@22-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 20@22-2' assembly/'Pipe #2 input at line 20@22-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@22-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 20@22-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object> Invoke(class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> _arg1) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               string V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance !1 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_0008:  stloc.1
+      IL_0009:  ldloc.0
+      IL_000a:  call       instance !0 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_000f:  stloc.2
+      IL_0010:  ldarg.0
+      IL_0011:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 20@22-3'::builder@
+      IL_0016:  ldloc.2
+      IL_0017:  ldloc.1
+      IL_0018:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                            !1)
+      IL_001d:  tail.
+      IL_001f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(!!0)
+      IL_0024:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@23-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 20@23-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> Invoke(class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                            !1)
+      IL_0015:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 20@23-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 20@23-4' assembly/'Pipe #2 input at line 20@23-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@30'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 28@30' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 28@30'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 28@30' assembly/'Pipe #3 input at line 28@30'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@30-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 28@30-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 28@30-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 28@30-1' assembly/'Pipe #3 input at line 28@30-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@30-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 28@30-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> 
+            Invoke(string c,
+                   class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                            !1)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 28@30-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 28@30-2' assembly/'Pipe #3 input at line 28@30-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@31-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps
+    .field public string c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps,
+                                 string c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@31-4'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly/'Pipe #3 input at line 28@31-4'::ps
+      IL_0014:  ldarg.0
+      IL_0015:  ldarg.3
+      IL_0016:  stfld      string assembly/'Pipe #3 input at line 28@31-4'::c
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object> Invoke(class [Utils]Utils/Product _arg2) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@31-4'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      string assembly/'Pipe #3 input at line 28@31-4'::c
+      IL_000e:  ldarg.0
+      IL_000f:  ldfld      class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly/'Pipe #3 input at line 28@31-4'::ps
+      IL_0014:  ldloc.0
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>::.ctor(!0,
+                                                                                                                                                                                                       !1,
+                                                                                                                                                                                                       !2)
+      IL_001a:  tail.
+      IL_001c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object>(!!0)
+      IL_0021:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@30-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@30-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable> Invoke(class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> _arg1) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               string V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance !1 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_0008:  stloc.1
+      IL_0009:  ldloc.0
+      IL_000a:  call       instance !0 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_000f:  stloc.2
+      IL_0010:  ldarg.0
+      IL_0011:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@30-3'::builder@
+      IL_0016:  ldarg.0
+      IL_0017:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@30-3'::builder@
+      IL_001c:  ldloc.1
+      IL_001d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0022:  ldarg.0
+      IL_0023:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@30-3'::builder@
+      IL_0028:  ldloc.1
+      IL_0029:  ldloc.2
+      IL_002a:  newobj     instance void assembly/'Pipe #3 input at line 28@31-4'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,
+                                                                                               string)
+      IL_002f:  tail.
+      IL_0031:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_0036:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@32-5'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 28@32-5' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,string> Invoke(class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               class [Utils]Utils/Product V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldarg.1
+      IL_000f:  call       instance !2 class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>::get_Item3()
+      IL_0014:  stloc.2
+      IL_0015:  ldloc.0
+      IL_0016:  ldloc.2
+      IL_0017:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_001c:  newobj     instance void class [runtime]System.Tuple`2<string,string>::.ctor(!0,
+                                                                                              !1)
+      IL_0021:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 28@32-5'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 28@32-5' assembly/'Pipe #3 input at line 28@32-5'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@39'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 37@39' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 37@39'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 37@39' assembly/'Pipe #4 input at line 37@39'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@39-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 37@39-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 37@39-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 37@39-1' assembly/'Pipe #4 input at line 37@39-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@39-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 37@39-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> 
+            Invoke(string c,
+                   class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                            !1)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 37@39-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 37@39-2' assembly/'Pipe #4 input at line 37@39-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@40-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps
+    .field public string c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps,
+                                 string c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@40-4'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 37@40-4'::ps
+      IL_0014:  ldarg.0
+      IL_0015:  ldarg.3
+      IL_0016:  stfld      string assembly/'Pipe #4 input at line 37@40-4'::c
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object> Invoke(class [Utils]Utils/Product _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [Utils]Utils/Product V_0,
+               string V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  nop
+      IL_0003:  ldloc.0
+      IL_0004:  box        [Utils]Utils/Product
+      IL_0009:  ldnull
+      IL_000a:  call       bool [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericEqualityIntrinsic<object>(!!0,
+                                                                                                                                    !!0)
+      IL_000f:  brfalse.s  IL_0019
+
+      IL_0011:  ldstr      "(No products)"
+      IL_0016:  nop
+      IL_0017:  br.s       IL_0020
+
+      IL_0019:  ldloc.0
+      IL_001a:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_001f:  nop
+      IL_0020:  stloc.1
+      IL_0021:  ldarg.0
+      IL_0022:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@40-4'::builder@
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      string assembly/'Pipe #4 input at line 37@40-4'::c
+      IL_002d:  ldarg.0
+      IL_002e:  ldfld      class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 37@40-4'::ps
+      IL_0033:  ldloc.0
+      IL_0034:  ldloc.1
+      IL_0035:  newobj     instance void class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::.ctor(!0,
+                                                                                                                                                                                                              !1,
+                                                                                                                                                                                                              !2,
+                                                                                                                                                                                                              !3)
+      IL_003a:  tail.
+      IL_003c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object>(!!0)
+      IL_0041:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@39-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@39-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable> Invoke(class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> _arg1) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               string V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance !1 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_0008:  stloc.1
+      IL_0009:  ldloc.0
+      IL_000a:  call       instance !0 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_000f:  stloc.2
+      IL_0010:  ldarg.0
+      IL_0011:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@39-3'::builder@
+      IL_0016:  ldarg.0
+      IL_0017:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@39-3'::builder@
+      IL_001c:  ldloc.1
+      IL_001d:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [System.Core]System.Linq.Enumerable::DefaultIfEmpty<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0022:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@39-3'::builder@
+      IL_002d:  ldloc.1
+      IL_002e:  ldloc.2
+      IL_002f:  newobj     instance void assembly/'Pipe #4 input at line 37@40-4'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,
+                                                                                               string)
+      IL_0034:  tail.
+      IL_0036:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_003b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@42-5'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Tuple`2<string,string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 37@42-5' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Tuple`2<string,string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,string> Invoke(class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               class [Utils]Utils/Product V_2,
+               string V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldarg.1
+      IL_000f:  call       instance !2 class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::get_Item3()
+      IL_0014:  stloc.2
+      IL_0015:  ldarg.1
+      IL_0016:  call       instance !3 class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::get_Item4()
+      IL_001b:  stloc.3
+      IL_001c:  ldloc.0
+      IL_001d:  ldloc.3
+      IL_001e:  newobj     instance void class [runtime]System.Tuple`2<string,string>::.ctor(!0,
+                                                                                              !1)
+      IL_0023:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 37@42-5'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 37@42-5' assembly/'Pipe #4 input at line 37@42-5'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> categories@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,string>[] q@11
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] q2@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,string>[] q3@27
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,string>[] q4@36
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_categories() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::categories@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,string>[] get_q() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q@11
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] get_q2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::q2@19
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,string>[] get_q3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q3@27
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,string>[] get_q4() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q4@36
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  10
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7)
+    IL_0000:  ldstr      "Beverages"
+    IL_0005:  ldstr      "Condiments"
+    IL_000a:  ldstr      "Vegetables"
+    IL_000f:  ldstr      "Dairy Products"
+    IL_0014:  ldstr      "Seafood"
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0037:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::categories@8
+    IL_003c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0041:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@9
+    IL_0046:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_004b:  stloc.1
+    IL_004c:  ldloc.1
+    IL_004d:  ldloc.1
+    IL_004e:  ldloc.1
+    IL_004f:  ldloc.1
+    IL_0050:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+    IL_0055:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_005a:  ldloc.1
+    IL_005b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_0060:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0065:  ldsfld     class assembly/'Pipe #1 input at line 12@14' assembly/'Pipe #1 input at line 12@14'::@_instance
+    IL_006a:  ldsfld     class assembly/'Pipe #1 input at line 12@14-1' assembly/'Pipe #1 input at line 12@14-1'::@_instance
+    IL_006f:  ldsfld     class assembly/'Pipe #1 input at line 12@14-2' assembly/'Pipe #1 input at line 12@14-2'::@_instance
+    IL_0074:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!4,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Join<string,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,string,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1>,
+                                                                                                                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>,
+                                                                                                                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!4>>)
+    IL_0079:  ldloc.1
+    IL_007a:  newobj     instance void assembly/'Pipe #1 input at line 12@14-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_007f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0084:  ldsfld     class assembly/'Pipe #1 input at line 12@15-4' assembly/'Pipe #1 input at line 12@15-4'::@_instance
+    IL_0089:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,string>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_008e:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,string>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0093:  stloc.0
+    IL_0094:  ldloc.0
+    IL_0095:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,string>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_009a:  stsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q@11
+    IL_009f:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00a4:  stloc.3
+    IL_00a5:  ldloc.3
+    IL_00a6:  ldloc.3
+    IL_00a7:  ldloc.3
+    IL_00a8:  ldloc.3
+    IL_00a9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+    IL_00ae:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00b3:  ldloc.3
+    IL_00b4:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_00b9:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00be:  ldsfld     class assembly/'Pipe #2 input at line 20@22' assembly/'Pipe #2 input at line 20@22'::@_instance
+    IL_00c3:  ldsfld     class assembly/'Pipe #2 input at line 20@22-1' assembly/'Pipe #2 input at line 20@22-1'::@_instance
+    IL_00c8:  ldsfld     class assembly/'Pipe #2 input at line 20@22-2' assembly/'Pipe #2 input at line 20@22-2'::@_instance
+    IL_00cd:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!4,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupJoin<string,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,string,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Collections.Generic.IEnumerable`1<!!2>,!!4>>)
+    IL_00d2:  ldloc.3
+    IL_00d3:  newobj     instance void assembly/'Pipe #2 input at line 20@22-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00dd:  ldsfld     class assembly/'Pipe #2 input at line 20@23-4' assembly/'Pipe #2 input at line 20@23-4'::@_instance
+    IL_00e2:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00e7:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00ec:  stloc.2
+    IL_00ed:  ldloc.2
+    IL_00ee:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00f3:  stsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::q2@19
+    IL_00f8:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00fd:  stloc.s    V_5
+    IL_00ff:  ldloc.s    V_5
+    IL_0101:  ldloc.s    V_5
+    IL_0103:  ldloc.s    V_5
+    IL_0105:  ldloc.s    V_5
+    IL_0107:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+    IL_010c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0111:  ldloc.s    V_5
+    IL_0113:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_0118:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_011d:  ldsfld     class assembly/'Pipe #3 input at line 28@30' assembly/'Pipe #3 input at line 28@30'::@_instance
+    IL_0122:  ldsfld     class assembly/'Pipe #3 input at line 28@30-1' assembly/'Pipe #3 input at line 28@30-1'::@_instance
+    IL_0127:  ldsfld     class assembly/'Pipe #3 input at line 28@30-2' assembly/'Pipe #3 input at line 28@30-2'::@_instance
+    IL_012c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!4,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupJoin<string,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,string,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Collections.Generic.IEnumerable`1<!!2>,!!4>>)
+    IL_0131:  ldloc.s    V_5
+    IL_0133:  newobj     instance void assembly/'Pipe #3 input at line 28@30-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0138:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_013d:  ldsfld     class assembly/'Pipe #3 input at line 28@32-5' assembly/'Pipe #3 input at line 28@32-5'::@_instance
+    IL_0142:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,string>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0147:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,string>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_014c:  stloc.s    V_4
+    IL_014e:  ldloc.s    V_4
+    IL_0150:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,string>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0155:  stsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q3@27
+    IL_015a:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_015f:  stloc.s    V_7
+    IL_0161:  ldloc.s    V_7
+    IL_0163:  ldloc.s    V_7
+    IL_0165:  ldloc.s    V_7
+    IL_0167:  ldloc.s    V_7
+    IL_0169:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+    IL_016e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0173:  ldloc.s    V_7
+    IL_0175:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_017a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_017f:  ldsfld     class assembly/'Pipe #4 input at line 37@39' assembly/'Pipe #4 input at line 37@39'::@_instance
+    IL_0184:  ldsfld     class assembly/'Pipe #4 input at line 37@39-1' assembly/'Pipe #4 input at line 37@39-1'::@_instance
+    IL_0189:  ldsfld     class assembly/'Pipe #4 input at line 37@39-2' assembly/'Pipe #4 input at line 37@39-2'::@_instance
+    IL_018e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!4,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupJoin<string,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,string,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Collections.Generic.IEnumerable`1<!!2>,!!4>>)
+    IL_0193:  ldloc.s    V_7
+    IL_0195:  newobj     instance void assembly/'Pipe #4 input at line 37@39-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_019a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_019f:  ldsfld     class assembly/'Pipe #4 input at line 37@42-5' assembly/'Pipe #4 input at line 37@42-5'::@_instance
+    IL_01a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,string>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01a9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,string>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_01ae:  stloc.s    V_6
+    IL_01b0:  ldloc.s    V_6
+    IL_01b2:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,string>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01b7:  stsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q4@36
+    IL_01bc:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          categories()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Tuple`2<string,string>[]
+          q()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,string>[] assembly::get_q()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[]
+          q2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::get_q2()
+  } 
+  .property class [runtime]System.Tuple`2<string,string>[]
+          q3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,string>[] assembly::get_q3()
+  } 
+  .property class [runtime]System.Tuple`2<string,string>[]
+          q4()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,string>[] assembly::get_q4()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOn.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOn.il.net472.release.bsl
new file mode 100644
index 00000000000..2851858eb06
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOn.il.net472.release.bsl
@@ -0,0 +1,1318 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern System.Core
+{
+  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         
+  .ver 4:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@14'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 12@14' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 12@14'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 12@14' assembly/'Pipe #1 input at line 12@14'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@14-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 12@14-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 12@14-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 12@14-1' assembly/'Pipe #1 input at line 12@14-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@14-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [Utils]Utils/Product,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 12@14-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [Utils]Utils/Product,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [Utils]Utils/Product> 
+            Invoke(string c,
+                   class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  newobj     instance void class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::.ctor(!0,
+                                                                                                                  !1)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 12@14-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 12@14-2' assembly/'Pipe #1 input at line 12@14-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@14-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 12@14-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object> Invoke(class [runtime]System.Tuple`2<string,class [Utils]Utils/Product> _arg1) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [runtime]System.Tuple`2<string,class [Utils]Utils/Product> V_0,
+               class [Utils]Utils/Product V_1,
+               string V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance !1 class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::get_Item2()
+      IL_0008:  stloc.1
+      IL_0009:  ldloc.0
+      IL_000a:  call       instance !0 class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::get_Item1()
+      IL_000f:  stloc.2
+      IL_0010:  ldarg.0
+      IL_0011:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 12@14-3'::builder@
+      IL_0016:  ldloc.2
+      IL_0017:  ldloc.1
+      IL_0018:  newobj     instance void class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::.ctor(!0,
+                                                                                                                  !1)
+      IL_001d:  tail.
+      IL_001f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object>(!!0)
+      IL_0024:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@15-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 12@15-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,string> Invoke(class [runtime]System.Tuple`2<string,class [Utils]Utils/Product> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,string>::.ctor(!0,
+                                                                                              !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 12@15-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 12@15-4' assembly/'Pipe #1 input at line 12@15-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@22'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 20@22' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 20@22'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 20@22' assembly/'Pipe #2 input at line 20@22'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@22-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 20@22-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 20@22-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 20@22-1' assembly/'Pipe #2 input at line 20@22-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@22-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 20@22-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> 
+            Invoke(string c,
+                   class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                            !1)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 20@22-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 20@22-2' assembly/'Pipe #2 input at line 20@22-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@22-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 20@22-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object> Invoke(class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> _arg1) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               string V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance !1 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_0008:  stloc.1
+      IL_0009:  ldloc.0
+      IL_000a:  call       instance !0 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_000f:  stloc.2
+      IL_0010:  ldarg.0
+      IL_0011:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 20@22-3'::builder@
+      IL_0016:  ldloc.2
+      IL_0017:  ldloc.1
+      IL_0018:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                            !1)
+      IL_001d:  tail.
+      IL_001f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(!!0)
+      IL_0024:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@23-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 20@23-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> Invoke(class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                            !1)
+      IL_0015:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 20@23-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 20@23-4' assembly/'Pipe #2 input at line 20@23-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@30'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 28@30' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 28@30'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 28@30' assembly/'Pipe #3 input at line 28@30'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@30-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 28@30-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 28@30-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 28@30-1' assembly/'Pipe #3 input at line 28@30-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@30-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 28@30-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> 
+            Invoke(string c,
+                   class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                            !1)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 28@30-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 28@30-2' assembly/'Pipe #3 input at line 28@30-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@31-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps
+    .field public string c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps,
+                                 string c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@31-4'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly/'Pipe #3 input at line 28@31-4'::ps
+      IL_0014:  ldarg.0
+      IL_0015:  ldarg.3
+      IL_0016:  stfld      string assembly/'Pipe #3 input at line 28@31-4'::c
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object> Invoke(class [Utils]Utils/Product _arg2) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@31-4'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      string assembly/'Pipe #3 input at line 28@31-4'::c
+      IL_000e:  ldarg.0
+      IL_000f:  ldfld      class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly/'Pipe #3 input at line 28@31-4'::ps
+      IL_0014:  ldloc.0
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>::.ctor(!0,
+                                                                                                                                                                                                       !1,
+                                                                                                                                                                                                       !2)
+      IL_001a:  tail.
+      IL_001c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object>(!!0)
+      IL_0021:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@30-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@30-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable> Invoke(class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> _arg1) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               string V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance !1 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_0008:  stloc.1
+      IL_0009:  ldloc.0
+      IL_000a:  call       instance !0 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_000f:  stloc.2
+      IL_0010:  ldarg.0
+      IL_0011:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@30-3'::builder@
+      IL_0016:  ldarg.0
+      IL_0017:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@30-3'::builder@
+      IL_001c:  ldloc.1
+      IL_001d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0022:  ldarg.0
+      IL_0023:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@30-3'::builder@
+      IL_0028:  ldloc.1
+      IL_0029:  ldloc.2
+      IL_002a:  newobj     instance void assembly/'Pipe #3 input at line 28@31-4'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,
+                                                                                               string)
+      IL_002f:  tail.
+      IL_0031:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_0036:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@32-5'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 28@32-5' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,string> Invoke(class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               class [Utils]Utils/Product V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldarg.1
+      IL_000f:  call       instance !2 class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>::get_Item3()
+      IL_0014:  stloc.2
+      IL_0015:  ldloc.0
+      IL_0016:  ldloc.2
+      IL_0017:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_001c:  newobj     instance void class [runtime]System.Tuple`2<string,string>::.ctor(!0,
+                                                                                              !1)
+      IL_0021:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 28@32-5'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 28@32-5' assembly/'Pipe #3 input at line 28@32-5'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@39'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 37@39' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 37@39'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 37@39' assembly/'Pipe #4 input at line 37@39'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@39-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 37@39-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 37@39-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 37@39-1' assembly/'Pipe #4 input at line 37@39-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@39-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 37@39-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> 
+            Invoke(string c,
+                   class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                            !1)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 37@39-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 37@39-2' assembly/'Pipe #4 input at line 37@39-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@40-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps
+    .field public string c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps,
+                                 string c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@40-4'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 37@40-4'::ps
+      IL_0014:  ldarg.0
+      IL_0015:  ldarg.3
+      IL_0016:  stfld      string assembly/'Pipe #4 input at line 37@40-4'::c
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object> Invoke(class [Utils]Utils/Product _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [Utils]Utils/Product V_0,
+               string V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  nop
+      IL_0003:  ldloc.0
+      IL_0004:  box        [Utils]Utils/Product
+      IL_0009:  ldnull
+      IL_000a:  call       bool [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericEqualityIntrinsic<object>(!!0,
+                                                                                                                                    !!0)
+      IL_000f:  brfalse.s  IL_0019
+
+      IL_0011:  ldstr      "(No products)"
+      IL_0016:  nop
+      IL_0017:  br.s       IL_0020
+
+      IL_0019:  ldloc.0
+      IL_001a:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_001f:  nop
+      IL_0020:  stloc.1
+      IL_0021:  ldarg.0
+      IL_0022:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@40-4'::builder@
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      string assembly/'Pipe #4 input at line 37@40-4'::c
+      IL_002d:  ldarg.0
+      IL_002e:  ldfld      class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 37@40-4'::ps
+      IL_0033:  ldloc.0
+      IL_0034:  ldloc.1
+      IL_0035:  newobj     instance void class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::.ctor(!0,
+                                                                                                                                                                                                              !1,
+                                                                                                                                                                                                              !2,
+                                                                                                                                                                                                              !3)
+      IL_003a:  tail.
+      IL_003c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object>(!!0)
+      IL_0041:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@39-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@39-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable> Invoke(class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> _arg1) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               string V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance !1 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_0008:  stloc.1
+      IL_0009:  ldloc.0
+      IL_000a:  call       instance !0 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_000f:  stloc.2
+      IL_0010:  ldarg.0
+      IL_0011:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@39-3'::builder@
+      IL_0016:  ldarg.0
+      IL_0017:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@39-3'::builder@
+      IL_001c:  ldloc.1
+      IL_001d:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [System.Core]System.Linq.Enumerable::DefaultIfEmpty<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0022:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@39-3'::builder@
+      IL_002d:  ldloc.1
+      IL_002e:  ldloc.2
+      IL_002f:  newobj     instance void assembly/'Pipe #4 input at line 37@40-4'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,
+                                                                                               string)
+      IL_0034:  tail.
+      IL_0036:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_003b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@42-5'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Tuple`2<string,string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 37@42-5' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Tuple`2<string,string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,string> Invoke(class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               class [Utils]Utils/Product V_2,
+               string V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldarg.1
+      IL_000f:  call       instance !2 class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::get_Item3()
+      IL_0014:  stloc.2
+      IL_0015:  ldarg.1
+      IL_0016:  call       instance !3 class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::get_Item4()
+      IL_001b:  stloc.3
+      IL_001c:  ldloc.0
+      IL_001d:  ldloc.3
+      IL_001e:  newobj     instance void class [runtime]System.Tuple`2<string,string>::.ctor(!0,
+                                                                                              !1)
+      IL_0023:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 37@42-5'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 37@42-5' assembly/'Pipe #4 input at line 37@42-5'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> categories@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,string>[] q@11
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] q2@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,string>[] q3@27
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,string>[] q4@36
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_categories() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::categories@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,string>[] get_q() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q@11
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] get_q2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::q2@19
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,string>[] get_q3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q3@27
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,string>[] get_q4() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q4@36
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  10
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7)
+    IL_0000:  ldstr      "Beverages"
+    IL_0005:  ldstr      "Condiments"
+    IL_000a:  ldstr      "Vegetables"
+    IL_000f:  ldstr      "Dairy Products"
+    IL_0014:  ldstr      "Seafood"
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0037:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::categories@8
+    IL_003c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0041:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@9
+    IL_0046:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_004b:  stloc.1
+    IL_004c:  ldloc.1
+    IL_004d:  ldloc.1
+    IL_004e:  ldloc.1
+    IL_004f:  ldloc.1
+    IL_0050:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+    IL_0055:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_005a:  ldloc.1
+    IL_005b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_0060:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0065:  ldsfld     class assembly/'Pipe #1 input at line 12@14' assembly/'Pipe #1 input at line 12@14'::@_instance
+    IL_006a:  ldsfld     class assembly/'Pipe #1 input at line 12@14-1' assembly/'Pipe #1 input at line 12@14-1'::@_instance
+    IL_006f:  ldsfld     class assembly/'Pipe #1 input at line 12@14-2' assembly/'Pipe #1 input at line 12@14-2'::@_instance
+    IL_0074:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!4,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Join<string,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,string,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1>,
+                                                                                                                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>,
+                                                                                                                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!4>>)
+    IL_0079:  ldloc.1
+    IL_007a:  newobj     instance void assembly/'Pipe #1 input at line 12@14-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_007f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0084:  ldsfld     class assembly/'Pipe #1 input at line 12@15-4' assembly/'Pipe #1 input at line 12@15-4'::@_instance
+    IL_0089:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,string>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_008e:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,string>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0093:  stloc.0
+    IL_0094:  ldloc.0
+    IL_0095:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,string>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_009a:  stsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q@11
+    IL_009f:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00a4:  stloc.3
+    IL_00a5:  ldloc.3
+    IL_00a6:  ldloc.3
+    IL_00a7:  ldloc.3
+    IL_00a8:  ldloc.3
+    IL_00a9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+    IL_00ae:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00b3:  ldloc.3
+    IL_00b4:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_00b9:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00be:  ldsfld     class assembly/'Pipe #2 input at line 20@22' assembly/'Pipe #2 input at line 20@22'::@_instance
+    IL_00c3:  ldsfld     class assembly/'Pipe #2 input at line 20@22-1' assembly/'Pipe #2 input at line 20@22-1'::@_instance
+    IL_00c8:  ldsfld     class assembly/'Pipe #2 input at line 20@22-2' assembly/'Pipe #2 input at line 20@22-2'::@_instance
+    IL_00cd:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!4,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupJoin<string,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,string,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Collections.Generic.IEnumerable`1<!!2>,!!4>>)
+    IL_00d2:  ldloc.3
+    IL_00d3:  newobj     instance void assembly/'Pipe #2 input at line 20@22-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00dd:  ldsfld     class assembly/'Pipe #2 input at line 20@23-4' assembly/'Pipe #2 input at line 20@23-4'::@_instance
+    IL_00e2:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00e7:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00ec:  stloc.2
+    IL_00ed:  ldloc.2
+    IL_00ee:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00f3:  stsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::q2@19
+    IL_00f8:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00fd:  stloc.s    V_5
+    IL_00ff:  ldloc.s    V_5
+    IL_0101:  ldloc.s    V_5
+    IL_0103:  ldloc.s    V_5
+    IL_0105:  ldloc.s    V_5
+    IL_0107:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+    IL_010c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0111:  ldloc.s    V_5
+    IL_0113:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_0118:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_011d:  ldsfld     class assembly/'Pipe #3 input at line 28@30' assembly/'Pipe #3 input at line 28@30'::@_instance
+    IL_0122:  ldsfld     class assembly/'Pipe #3 input at line 28@30-1' assembly/'Pipe #3 input at line 28@30-1'::@_instance
+    IL_0127:  ldsfld     class assembly/'Pipe #3 input at line 28@30-2' assembly/'Pipe #3 input at line 28@30-2'::@_instance
+    IL_012c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!4,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupJoin<string,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,string,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Collections.Generic.IEnumerable`1<!!2>,!!4>>)
+    IL_0131:  ldloc.s    V_5
+    IL_0133:  newobj     instance void assembly/'Pipe #3 input at line 28@30-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0138:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_013d:  ldsfld     class assembly/'Pipe #3 input at line 28@32-5' assembly/'Pipe #3 input at line 28@32-5'::@_instance
+    IL_0142:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,string>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0147:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,string>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_014c:  stloc.s    V_4
+    IL_014e:  ldloc.s    V_4
+    IL_0150:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,string>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0155:  stsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q3@27
+    IL_015a:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_015f:  stloc.s    V_7
+    IL_0161:  ldloc.s    V_7
+    IL_0163:  ldloc.s    V_7
+    IL_0165:  ldloc.s    V_7
+    IL_0167:  ldloc.s    V_7
+    IL_0169:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+    IL_016e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0173:  ldloc.s    V_7
+    IL_0175:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_017a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_017f:  ldsfld     class assembly/'Pipe #4 input at line 37@39' assembly/'Pipe #4 input at line 37@39'::@_instance
+    IL_0184:  ldsfld     class assembly/'Pipe #4 input at line 37@39-1' assembly/'Pipe #4 input at line 37@39-1'::@_instance
+    IL_0189:  ldsfld     class assembly/'Pipe #4 input at line 37@39-2' assembly/'Pipe #4 input at line 37@39-2'::@_instance
+    IL_018e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!4,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupJoin<string,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,string,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Collections.Generic.IEnumerable`1<!!2>,!!4>>)
+    IL_0193:  ldloc.s    V_7
+    IL_0195:  newobj     instance void assembly/'Pipe #4 input at line 37@39-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_019a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_019f:  ldsfld     class assembly/'Pipe #4 input at line 37@42-5' assembly/'Pipe #4 input at line 37@42-5'::@_instance
+    IL_01a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,string>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01a9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,string>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_01ae:  stloc.s    V_6
+    IL_01b0:  ldloc.s    V_6
+    IL_01b2:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,string>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01b7:  stsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q4@36
+    IL_01bc:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          categories()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Tuple`2<string,string>[]
+          q()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,string>[] assembly::get_q()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[]
+          q2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::get_q2()
+  } 
+  .property class [runtime]System.Tuple`2<string,string>[]
+          q3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,string>[] assembly::get_q3()
+  } 
+  .property class [runtime]System.Tuple`2<string,string>[]
+          q4()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,string>[] assembly::get_q4()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOn.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
new file mode 100644
index 00000000000..88c309312cf
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
@@ -0,0 +1,1318 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern System.Linq
+{
+  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         
+  .ver 8:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@14'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 12@14' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 12@14'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 12@14' assembly/'Pipe #1 input at line 12@14'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@14-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 12@14-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 12@14-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 12@14-1' assembly/'Pipe #1 input at line 12@14-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@14-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [Utils]Utils/Product,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 12@14-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [Utils]Utils/Product,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [Utils]Utils/Product> 
+            Invoke(string c,
+                   class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  newobj     instance void class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::.ctor(!0,
+                                                                                                                        !1)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 12@14-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 12@14-2' assembly/'Pipe #1 input at line 12@14-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@14-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 12@14-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object> Invoke(class [runtime]System.Tuple`2<string,class [Utils]Utils/Product> _arg1) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [runtime]System.Tuple`2<string,class [Utils]Utils/Product> V_0,
+               class [Utils]Utils/Product V_1,
+               string V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance !1 class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::get_Item2()
+      IL_0008:  stloc.1
+      IL_0009:  ldloc.0
+      IL_000a:  call       instance !0 class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::get_Item1()
+      IL_000f:  stloc.2
+      IL_0010:  ldarg.0
+      IL_0011:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 12@14-3'::builder@
+      IL_0016:  ldloc.2
+      IL_0017:  ldloc.1
+      IL_0018:  newobj     instance void class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::.ctor(!0,
+                                                                                                                        !1)
+      IL_001d:  tail.
+      IL_001f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object>(!!0)
+      IL_0024:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@15-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 12@15-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,string> Invoke(class [runtime]System.Tuple`2<string,class [Utils]Utils/Product> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,string>::.ctor(!0,
+                                                                                                    !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 12@15-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 12@15-4' assembly/'Pipe #1 input at line 12@15-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@22'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 20@22' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 20@22'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 20@22' assembly/'Pipe #2 input at line 20@22'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@22-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 20@22-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 20@22-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 20@22-1' assembly/'Pipe #2 input at line 20@22-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@22-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 20@22-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> 
+            Invoke(string c,
+                   class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                        !1)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 20@22-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 20@22-2' assembly/'Pipe #2 input at line 20@22-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@22-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 20@22-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object> Invoke(class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> _arg1) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               string V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance !1 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_0008:  stloc.1
+      IL_0009:  ldloc.0
+      IL_000a:  call       instance !0 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_000f:  stloc.2
+      IL_0010:  ldarg.0
+      IL_0011:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 20@22-3'::builder@
+      IL_0016:  ldloc.2
+      IL_0017:  ldloc.1
+      IL_0018:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                        !1)
+      IL_001d:  tail.
+      IL_001f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(!!0)
+      IL_0024:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@23-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 20@23-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> Invoke(class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                        !1)
+      IL_0015:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 20@23-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 20@23-4' assembly/'Pipe #2 input at line 20@23-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@30'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 28@30' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 28@30'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 28@30' assembly/'Pipe #3 input at line 28@30'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@30-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 28@30-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 28@30-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 28@30-1' assembly/'Pipe #3 input at line 28@30-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@30-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 28@30-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> 
+            Invoke(string c,
+                   class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                        !1)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 28@30-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 28@30-2' assembly/'Pipe #3 input at line 28@30-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@31-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps
+    .field public string c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps,
+                                 string c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@31-4'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly/'Pipe #3 input at line 28@31-4'::ps
+      IL_0014:  ldarg.0
+      IL_0015:  ldarg.3
+      IL_0016:  stfld      string assembly/'Pipe #3 input at line 28@31-4'::c
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object> Invoke(class [Utils]Utils/Product _arg2) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@31-4'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      string assembly/'Pipe #3 input at line 28@31-4'::c
+      IL_000e:  ldarg.0
+      IL_000f:  ldfld      class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly/'Pipe #3 input at line 28@31-4'::ps
+      IL_0014:  ldloc.0
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>::.ctor(!0,
+                                                                                                                                                                                                                   !1,
+                                                                                                                                                                                                                   !2)
+      IL_001a:  tail.
+      IL_001c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object>(!!0)
+      IL_0021:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@30-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@30-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable> Invoke(class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> _arg1) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               string V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance !1 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_0008:  stloc.1
+      IL_0009:  ldloc.0
+      IL_000a:  call       instance !0 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_000f:  stloc.2
+      IL_0010:  ldarg.0
+      IL_0011:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@30-3'::builder@
+      IL_0016:  ldarg.0
+      IL_0017:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@30-3'::builder@
+      IL_001c:  ldloc.1
+      IL_001d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0022:  ldarg.0
+      IL_0023:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@30-3'::builder@
+      IL_0028:  ldloc.1
+      IL_0029:  ldloc.2
+      IL_002a:  newobj     instance void assembly/'Pipe #3 input at line 28@31-4'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,
+                                                                                               string)
+      IL_002f:  tail.
+      IL_0031:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_0036:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@32-5'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 28@32-5' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,string> Invoke(class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               class [Utils]Utils/Product V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldarg.1
+      IL_000f:  call       instance !2 class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>::get_Item3()
+      IL_0014:  stloc.2
+      IL_0015:  ldloc.0
+      IL_0016:  ldloc.2
+      IL_0017:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_001c:  newobj     instance void class [runtime]System.Tuple`2<string,string>::.ctor(!0,
+                                                                                                    !1)
+      IL_0021:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 28@32-5'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 28@32-5' assembly/'Pipe #3 input at line 28@32-5'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@39'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 37@39' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 37@39'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 37@39' assembly/'Pipe #4 input at line 37@39'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@39-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 37@39-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 37@39-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 37@39-1' assembly/'Pipe #4 input at line 37@39-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@39-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 37@39-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> 
+            Invoke(string c,
+                   class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                        !1)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 37@39-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 37@39-2' assembly/'Pipe #4 input at line 37@39-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@40-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps
+    .field public string c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps,
+                                 string c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@40-4'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 37@40-4'::ps
+      IL_0014:  ldarg.0
+      IL_0015:  ldarg.3
+      IL_0016:  stfld      string assembly/'Pipe #4 input at line 37@40-4'::c
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object> Invoke(class [Utils]Utils/Product _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [Utils]Utils/Product V_0,
+               string V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  nop
+      IL_0003:  ldloc.0
+      IL_0004:  box        [Utils]Utils/Product
+      IL_0009:  ldnull
+      IL_000a:  call       bool [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericEqualityIntrinsic<object>(!!0,
+                                                                                                                                    !!0)
+      IL_000f:  brfalse.s  IL_0019
+
+      IL_0011:  ldstr      "(No products)"
+      IL_0016:  nop
+      IL_0017:  br.s       IL_0020
+
+      IL_0019:  ldloc.0
+      IL_001a:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_001f:  nop
+      IL_0020:  stloc.1
+      IL_0021:  ldarg.0
+      IL_0022:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@40-4'::builder@
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      string assembly/'Pipe #4 input at line 37@40-4'::c
+      IL_002d:  ldarg.0
+      IL_002e:  ldfld      class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 37@40-4'::ps
+      IL_0033:  ldloc.0
+      IL_0034:  ldloc.1
+      IL_0035:  newobj     instance void class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::.ctor(!0,
+                                                                                                                                                                                                                          !1,
+                                                                                                                                                                                                                          !2,
+                                                                                                                                                                                                                          !3)
+      IL_003a:  tail.
+      IL_003c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object>(!!0)
+      IL_0041:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@39-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@39-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable> Invoke(class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> _arg1) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               string V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance !1 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_0008:  stloc.1
+      IL_0009:  ldloc.0
+      IL_000a:  call       instance !0 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_000f:  stloc.2
+      IL_0010:  ldarg.0
+      IL_0011:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@39-3'::builder@
+      IL_0016:  ldarg.0
+      IL_0017:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@39-3'::builder@
+      IL_001c:  ldloc.1
+      IL_001d:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [System.Linq]System.Linq.Enumerable::DefaultIfEmpty<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0022:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@39-3'::builder@
+      IL_002d:  ldloc.1
+      IL_002e:  ldloc.2
+      IL_002f:  newobj     instance void assembly/'Pipe #4 input at line 37@40-4'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,
+                                                                                               string)
+      IL_0034:  tail.
+      IL_0036:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_003b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@42-5'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Tuple`2<string,string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 37@42-5' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Tuple`2<string,string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,string> Invoke(class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               class [Utils]Utils/Product V_2,
+               string V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldarg.1
+      IL_000f:  call       instance !2 class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::get_Item3()
+      IL_0014:  stloc.2
+      IL_0015:  ldarg.1
+      IL_0016:  call       instance !3 class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::get_Item4()
+      IL_001b:  stloc.3
+      IL_001c:  ldloc.0
+      IL_001d:  ldloc.3
+      IL_001e:  newobj     instance void class [runtime]System.Tuple`2<string,string>::.ctor(!0,
+                                                                                                    !1)
+      IL_0023:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 37@42-5'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 37@42-5' assembly/'Pipe #4 input at line 37@42-5'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> categories@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,string>[] q@11
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] q2@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,string>[] q3@27
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,string>[] q4@36
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_categories() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::categories@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,string>[] get_q() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q@11
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] get_q2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::q2@19
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,string>[] get_q3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q3@27
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,string>[] get_q4() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q4@36
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  10
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7)
+    IL_0000:  ldstr      "Beverages"
+    IL_0005:  ldstr      "Condiments"
+    IL_000a:  ldstr      "Vegetables"
+    IL_000f:  ldstr      "Dairy Products"
+    IL_0014:  ldstr      "Seafood"
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0037:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::categories@8
+    IL_003c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0041:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@9
+    IL_0046:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_004b:  stloc.1
+    IL_004c:  ldloc.1
+    IL_004d:  ldloc.1
+    IL_004e:  ldloc.1
+    IL_004f:  ldloc.1
+    IL_0050:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+    IL_0055:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_005a:  ldloc.1
+    IL_005b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_0060:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0065:  ldsfld     class assembly/'Pipe #1 input at line 12@14' assembly/'Pipe #1 input at line 12@14'::@_instance
+    IL_006a:  ldsfld     class assembly/'Pipe #1 input at line 12@14-1' assembly/'Pipe #1 input at line 12@14-1'::@_instance
+    IL_006f:  ldsfld     class assembly/'Pipe #1 input at line 12@14-2' assembly/'Pipe #1 input at line 12@14-2'::@_instance
+    IL_0074:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!4,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Join<string,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,string,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1>,
+                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>,
+                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!4>>)
+    IL_0079:  ldloc.1
+    IL_007a:  newobj     instance void assembly/'Pipe #1 input at line 12@14-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_007f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0084:  ldsfld     class assembly/'Pipe #1 input at line 12@15-4' assembly/'Pipe #1 input at line 12@15-4'::@_instance
+    IL_0089:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,string>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_008e:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,string>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0093:  stloc.0
+    IL_0094:  ldloc.0
+    IL_0095:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,string>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_009a:  stsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q@11
+    IL_009f:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00a4:  stloc.3
+    IL_00a5:  ldloc.3
+    IL_00a6:  ldloc.3
+    IL_00a7:  ldloc.3
+    IL_00a8:  ldloc.3
+    IL_00a9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+    IL_00ae:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00b3:  ldloc.3
+    IL_00b4:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_00b9:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00be:  ldsfld     class assembly/'Pipe #2 input at line 20@22' assembly/'Pipe #2 input at line 20@22'::@_instance
+    IL_00c3:  ldsfld     class assembly/'Pipe #2 input at line 20@22-1' assembly/'Pipe #2 input at line 20@22-1'::@_instance
+    IL_00c8:  ldsfld     class assembly/'Pipe #2 input at line 20@22-2' assembly/'Pipe #2 input at line 20@22-2'::@_instance
+    IL_00cd:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!4,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupJoin<string,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,string,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Collections.Generic.IEnumerable`1<!!2>,!!4>>)
+    IL_00d2:  ldloc.3
+    IL_00d3:  newobj     instance void assembly/'Pipe #2 input at line 20@22-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00dd:  ldsfld     class assembly/'Pipe #2 input at line 20@23-4' assembly/'Pipe #2 input at line 20@23-4'::@_instance
+    IL_00e2:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00e7:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00ec:  stloc.2
+    IL_00ed:  ldloc.2
+    IL_00ee:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00f3:  stsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::q2@19
+    IL_00f8:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00fd:  stloc.s    V_5
+    IL_00ff:  ldloc.s    V_5
+    IL_0101:  ldloc.s    V_5
+    IL_0103:  ldloc.s    V_5
+    IL_0105:  ldloc.s    V_5
+    IL_0107:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+    IL_010c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0111:  ldloc.s    V_5
+    IL_0113:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_0118:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_011d:  ldsfld     class assembly/'Pipe #3 input at line 28@30' assembly/'Pipe #3 input at line 28@30'::@_instance
+    IL_0122:  ldsfld     class assembly/'Pipe #3 input at line 28@30-1' assembly/'Pipe #3 input at line 28@30-1'::@_instance
+    IL_0127:  ldsfld     class assembly/'Pipe #3 input at line 28@30-2' assembly/'Pipe #3 input at line 28@30-2'::@_instance
+    IL_012c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!4,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupJoin<string,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,string,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Collections.Generic.IEnumerable`1<!!2>,!!4>>)
+    IL_0131:  ldloc.s    V_5
+    IL_0133:  newobj     instance void assembly/'Pipe #3 input at line 28@30-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0138:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_013d:  ldsfld     class assembly/'Pipe #3 input at line 28@32-5' assembly/'Pipe #3 input at line 28@32-5'::@_instance
+    IL_0142:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,string>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0147:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,string>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_014c:  stloc.s    V_4
+    IL_014e:  ldloc.s    V_4
+    IL_0150:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,string>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0155:  stsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q3@27
+    IL_015a:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_015f:  stloc.s    V_7
+    IL_0161:  ldloc.s    V_7
+    IL_0163:  ldloc.s    V_7
+    IL_0165:  ldloc.s    V_7
+    IL_0167:  ldloc.s    V_7
+    IL_0169:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+    IL_016e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0173:  ldloc.s    V_7
+    IL_0175:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_017a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_017f:  ldsfld     class assembly/'Pipe #4 input at line 37@39' assembly/'Pipe #4 input at line 37@39'::@_instance
+    IL_0184:  ldsfld     class assembly/'Pipe #4 input at line 37@39-1' assembly/'Pipe #4 input at line 37@39-1'::@_instance
+    IL_0189:  ldsfld     class assembly/'Pipe #4 input at line 37@39-2' assembly/'Pipe #4 input at line 37@39-2'::@_instance
+    IL_018e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!4,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupJoin<string,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,string,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Collections.Generic.IEnumerable`1<!!2>,!!4>>)
+    IL_0193:  ldloc.s    V_7
+    IL_0195:  newobj     instance void assembly/'Pipe #4 input at line 37@39-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_019a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_019f:  ldsfld     class assembly/'Pipe #4 input at line 37@42-5' assembly/'Pipe #4 input at line 37@42-5'::@_instance
+    IL_01a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,string>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01a9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,string>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_01ae:  stloc.s    V_6
+    IL_01b0:  ldloc.s    V_6
+    IL_01b2:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,string>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01b7:  stsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q4@36
+    IL_01bc:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          categories()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Tuple`2<string,string>[]
+          q()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,string>[] assembly::get_q()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[]
+          q2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::get_q2()
+  } 
+  .property class [runtime]System.Tuple`2<string,string>[]
+          q3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,string>[] assembly::get_q3()
+  } 
+  .property class [runtime]System.Tuple`2<string,string>[]
+          q4()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,string>[] assembly::get_q4()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOn.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOn.il.netcore.release.bsl
new file mode 100644
index 00000000000..88c309312cf
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Joins01.fs.RealInternalSignatureOn.il.netcore.release.bsl
@@ -0,0 +1,1318 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern System.Linq
+{
+  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         
+  .ver 8:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@14'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 12@14' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 12@14'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 12@14' assembly/'Pipe #1 input at line 12@14'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@14-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 12@14-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 12@14-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 12@14-1' assembly/'Pipe #1 input at line 12@14-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@14-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [Utils]Utils/Product,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 12@14-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [Utils]Utils/Product,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [Utils]Utils/Product> 
+            Invoke(string c,
+                   class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  newobj     instance void class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::.ctor(!0,
+                                                                                                                        !1)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 12@14-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 12@14-2' assembly/'Pipe #1 input at line 12@14-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@14-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 12@14-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object> Invoke(class [runtime]System.Tuple`2<string,class [Utils]Utils/Product> _arg1) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [runtime]System.Tuple`2<string,class [Utils]Utils/Product> V_0,
+               class [Utils]Utils/Product V_1,
+               string V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance !1 class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::get_Item2()
+      IL_0008:  stloc.1
+      IL_0009:  ldloc.0
+      IL_000a:  call       instance !0 class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::get_Item1()
+      IL_000f:  stloc.2
+      IL_0010:  ldarg.0
+      IL_0011:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 12@14-3'::builder@
+      IL_0016:  ldloc.2
+      IL_0017:  ldloc.1
+      IL_0018:  newobj     instance void class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::.ctor(!0,
+                                                                                                                        !1)
+      IL_001d:  tail.
+      IL_001f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object>(!!0)
+      IL_0024:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 12@15-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 12@15-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,string> Invoke(class [runtime]System.Tuple`2<string,class [Utils]Utils/Product> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`2<string,string>::.ctor(!0,
+                                                                                                    !1)
+      IL_001a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 12@15-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 12@15-4' assembly/'Pipe #1 input at line 12@15-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@22'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 20@22' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 20@22'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 20@22' assembly/'Pipe #2 input at line 20@22'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@22-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 20@22-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 20@22-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 20@22-1' assembly/'Pipe #2 input at line 20@22-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@22-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 20@22-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> 
+            Invoke(string c,
+                   class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                        !1)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 20@22-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 20@22-2' assembly/'Pipe #2 input at line 20@22-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@22-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 20@22-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object> Invoke(class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> _arg1) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               string V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance !1 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_0008:  stloc.1
+      IL_0009:  ldloc.0
+      IL_000a:  call       instance !0 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_000f:  stloc.2
+      IL_0010:  ldarg.0
+      IL_0011:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 20@22-3'::builder@
+      IL_0016:  ldloc.2
+      IL_0017:  ldloc.1
+      IL_0018:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                        !1)
+      IL_001d:  tail.
+      IL_001f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(!!0)
+      IL_0024:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 20@23-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 20@23-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> Invoke(class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                        !1)
+      IL_0015:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 20@23-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 20@23-4' assembly/'Pipe #2 input at line 20@23-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@30'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 28@30' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 28@30'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 28@30' assembly/'Pipe #3 input at line 28@30'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@30-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 28@30-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 28@30-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 28@30-1' assembly/'Pipe #3 input at line 28@30-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@30-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 28@30-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> 
+            Invoke(string c,
+                   class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                        !1)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 28@30-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 28@30-2' assembly/'Pipe #3 input at line 28@30-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@31-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps
+    .field public string c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps,
+                                 string c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@31-4'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly/'Pipe #3 input at line 28@31-4'::ps
+      IL_0014:  ldarg.0
+      IL_0015:  ldarg.3
+      IL_0016:  stfld      string assembly/'Pipe #3 input at line 28@31-4'::c
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object> Invoke(class [Utils]Utils/Product _arg2) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@31-4'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      string assembly/'Pipe #3 input at line 28@31-4'::c
+      IL_000e:  ldarg.0
+      IL_000f:  ldfld      class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly/'Pipe #3 input at line 28@31-4'::ps
+      IL_0014:  ldloc.0
+      IL_0015:  newobj     instance void class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>::.ctor(!0,
+                                                                                                                                                                                                                   !1,
+                                                                                                                                                                                                                   !2)
+      IL_001a:  tail.
+      IL_001c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object>(!!0)
+      IL_0021:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@30-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@30-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable> Invoke(class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> _arg1) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               string V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance !1 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_0008:  stloc.1
+      IL_0009:  ldloc.0
+      IL_000a:  call       instance !0 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_000f:  stloc.2
+      IL_0010:  ldarg.0
+      IL_0011:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@30-3'::builder@
+      IL_0016:  ldarg.0
+      IL_0017:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@30-3'::builder@
+      IL_001c:  ldloc.1
+      IL_001d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0022:  ldarg.0
+      IL_0023:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 28@30-3'::builder@
+      IL_0028:  ldloc.1
+      IL_0029:  ldloc.2
+      IL_002a:  newobj     instance void assembly/'Pipe #3 input at line 28@31-4'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,
+                                                                                               string)
+      IL_002f:  tail.
+      IL_0031:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_0036:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 28@32-5'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 28@32-5' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,string> Invoke(class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               class [Utils]Utils/Product V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldarg.1
+      IL_000f:  call       instance !2 class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>::get_Item3()
+      IL_0014:  stloc.2
+      IL_0015:  ldloc.0
+      IL_0016:  ldloc.2
+      IL_0017:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_001c:  newobj     instance void class [runtime]System.Tuple`2<string,string>::.ctor(!0,
+                                                                                                    !1)
+      IL_0021:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 28@32-5'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 28@32-5' assembly/'Pipe #3 input at line 28@32-5'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@39'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 37@39' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 37@39'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 37@39' assembly/'Pipe #4 input at line 37@39'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@39-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 37@39-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 37@39-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 37@39-1' assembly/'Pipe #4 input at line 37@39-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@39-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 37@39-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> 
+            Invoke(string c,
+                   class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.2
+      IL_0002:  newobj     instance void class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                                        !1)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 37@39-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 37@39-2' assembly/'Pipe #4 input at line 37@39-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@40-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps
+    .field public string c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> ps,
+                                 string c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@40-4'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 37@40-4'::ps
+      IL_0014:  ldarg.0
+      IL_0015:  ldarg.3
+      IL_0016:  stfld      string assembly/'Pipe #4 input at line 37@40-4'::c
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object> Invoke(class [Utils]Utils/Product _arg2) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [Utils]Utils/Product V_0,
+               string V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  nop
+      IL_0003:  ldloc.0
+      IL_0004:  box        [Utils]Utils/Product
+      IL_0009:  ldnull
+      IL_000a:  call       bool [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericEqualityIntrinsic<object>(!!0,
+                                                                                                                                    !!0)
+      IL_000f:  brfalse.s  IL_0019
+
+      IL_0011:  ldstr      "(No products)"
+      IL_0016:  nop
+      IL_0017:  br.s       IL_0020
+
+      IL_0019:  ldloc.0
+      IL_001a:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_001f:  nop
+      IL_0020:  stloc.1
+      IL_0021:  ldarg.0
+      IL_0022:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@40-4'::builder@
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      string assembly/'Pipe #4 input at line 37@40-4'::c
+      IL_002d:  ldarg.0
+      IL_002e:  ldfld      class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 37@40-4'::ps
+      IL_0033:  ldloc.0
+      IL_0034:  ldloc.1
+      IL_0035:  newobj     instance void class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::.ctor(!0,
+                                                                                                                                                                                                                          !1,
+                                                                                                                                                                                                                          !2,
+                                                                                                                                                                                                                          !3)
+      IL_003a:  tail.
+      IL_003c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object>(!!0)
+      IL_0041:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@39-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@39-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable> Invoke(class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> _arg1) cil managed
+    {
+      
+      .maxstack  9
+      .locals init (class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>> V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               string V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance !1 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item2()
+      IL_0008:  stloc.1
+      IL_0009:  ldloc.0
+      IL_000a:  call       instance !0 class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::get_Item1()
+      IL_000f:  stloc.2
+      IL_0010:  ldarg.0
+      IL_0011:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@39-3'::builder@
+      IL_0016:  ldarg.0
+      IL_0017:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@39-3'::builder@
+      IL_001c:  ldloc.1
+      IL_001d:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [System.Linq]System.Linq.Enumerable::DefaultIfEmpty<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0022:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0027:  ldarg.0
+      IL_0028:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 37@39-3'::builder@
+      IL_002d:  ldloc.1
+      IL_002e:  ldloc.2
+      IL_002f:  newobj     instance void assembly/'Pipe #4 input at line 37@40-4'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,
+                                                                                               string)
+      IL_0034:  tail.
+      IL_0036:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_003b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 37@42-5'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Tuple`2<string,string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 37@42-5' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Tuple`2<string,string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,string> Invoke(class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_1,
+               class [Utils]Utils/Product V_2,
+               string V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldarg.1
+      IL_000f:  call       instance !2 class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::get_Item3()
+      IL_0014:  stloc.2
+      IL_0015:  ldarg.1
+      IL_0016:  call       instance !3 class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>::get_Item4()
+      IL_001b:  stloc.3
+      IL_001c:  ldloc.0
+      IL_001d:  ldloc.3
+      IL_001e:  newobj     instance void class [runtime]System.Tuple`2<string,string>::.ctor(!0,
+                                                                                                    !1)
+      IL_0023:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 37@42-5'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 37@42-5' assembly/'Pipe #4 input at line 37@42-5'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> categories@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,string>[] q@11
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] q2@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,string>[] q3@27
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,string>[] q4@36
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_categories() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::categories@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,string>[] get_q() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q@11
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] get_q2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::q2@19
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,string>[] get_q3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q3@27
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,string>[] get_q4() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q4@36
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  10
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7)
+    IL_0000:  ldstr      "Beverages"
+    IL_0005:  ldstr      "Condiments"
+    IL_000a:  ldstr      "Vegetables"
+    IL_000f:  ldstr      "Dairy Products"
+    IL_0014:  ldstr      "Seafood"
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0037:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::categories@8
+    IL_003c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0041:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@9
+    IL_0046:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_004b:  stloc.1
+    IL_004c:  ldloc.1
+    IL_004d:  ldloc.1
+    IL_004e:  ldloc.1
+    IL_004f:  ldloc.1
+    IL_0050:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+    IL_0055:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_005a:  ldloc.1
+    IL_005b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_0060:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0065:  ldsfld     class assembly/'Pipe #1 input at line 12@14' assembly/'Pipe #1 input at line 12@14'::@_instance
+    IL_006a:  ldsfld     class assembly/'Pipe #1 input at line 12@14-1' assembly/'Pipe #1 input at line 12@14-1'::@_instance
+    IL_006f:  ldsfld     class assembly/'Pipe #1 input at line 12@14-2' assembly/'Pipe #1 input at line 12@14-2'::@_instance
+    IL_0074:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!4,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Join<string,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,string,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1>,
+                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>,
+                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!4>>)
+    IL_0079:  ldloc.1
+    IL_007a:  newobj     instance void assembly/'Pipe #1 input at line 12@14-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_007f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0084:  ldsfld     class assembly/'Pipe #1 input at line 12@15-4' assembly/'Pipe #1 input at line 12@15-4'::@_instance
+    IL_0089:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,string>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_008e:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,string>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0093:  stloc.0
+    IL_0094:  ldloc.0
+    IL_0095:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,string>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_009a:  stsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q@11
+    IL_009f:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00a4:  stloc.3
+    IL_00a5:  ldloc.3
+    IL_00a6:  ldloc.3
+    IL_00a7:  ldloc.3
+    IL_00a8:  ldloc.3
+    IL_00a9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+    IL_00ae:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00b3:  ldloc.3
+    IL_00b4:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_00b9:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00be:  ldsfld     class assembly/'Pipe #2 input at line 20@22' assembly/'Pipe #2 input at line 20@22'::@_instance
+    IL_00c3:  ldsfld     class assembly/'Pipe #2 input at line 20@22-1' assembly/'Pipe #2 input at line 20@22-1'::@_instance
+    IL_00c8:  ldsfld     class assembly/'Pipe #2 input at line 20@22-2' assembly/'Pipe #2 input at line 20@22-2'::@_instance
+    IL_00cd:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!4,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupJoin<string,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,string,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Collections.Generic.IEnumerable`1<!!2>,!!4>>)
+    IL_00d2:  ldloc.3
+    IL_00d3:  newobj     instance void assembly/'Pipe #2 input at line 20@22-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00dd:  ldsfld     class assembly/'Pipe #2 input at line 20@23-4' assembly/'Pipe #2 input at line 20@23-4'::@_instance
+    IL_00e2:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00e7:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00ec:  stloc.2
+    IL_00ed:  ldloc.2
+    IL_00ee:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00f3:  stsfld     class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::q2@19
+    IL_00f8:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00fd:  stloc.s    V_5
+    IL_00ff:  ldloc.s    V_5
+    IL_0101:  ldloc.s    V_5
+    IL_0103:  ldloc.s    V_5
+    IL_0105:  ldloc.s    V_5
+    IL_0107:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+    IL_010c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0111:  ldloc.s    V_5
+    IL_0113:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_0118:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_011d:  ldsfld     class assembly/'Pipe #3 input at line 28@30' assembly/'Pipe #3 input at line 28@30'::@_instance
+    IL_0122:  ldsfld     class assembly/'Pipe #3 input at line 28@30-1' assembly/'Pipe #3 input at line 28@30-1'::@_instance
+    IL_0127:  ldsfld     class assembly/'Pipe #3 input at line 28@30-2' assembly/'Pipe #3 input at line 28@30-2'::@_instance
+    IL_012c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!4,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupJoin<string,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,string,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Collections.Generic.IEnumerable`1<!!2>,!!4>>)
+    IL_0131:  ldloc.s    V_5
+    IL_0133:  newobj     instance void assembly/'Pipe #3 input at line 28@30-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0138:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_013d:  ldsfld     class assembly/'Pipe #3 input at line 28@32-5' assembly/'Pipe #3 input at line 28@32-5'::@_instance
+    IL_0142:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`3<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,string>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0147:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,string>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_014c:  stloc.s    V_4
+    IL_014e:  ldloc.s    V_4
+    IL_0150:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,string>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0155:  stsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q3@27
+    IL_015a:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_015f:  stloc.s    V_7
+    IL_0161:  ldloc.s    V_7
+    IL_0163:  ldloc.s    V_7
+    IL_0165:  ldloc.s    V_7
+    IL_0167:  ldloc.s    V_7
+    IL_0169:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+    IL_016e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0173:  ldloc.s    V_7
+    IL_0175:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_017a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_017f:  ldsfld     class assembly/'Pipe #4 input at line 37@39' assembly/'Pipe #4 input at line 37@39'::@_instance
+    IL_0184:  ldsfld     class assembly/'Pipe #4 input at line 37@39-1' assembly/'Pipe #4 input at line 37@39-1'::@_instance
+    IL_0189:  ldsfld     class assembly/'Pipe #4 input at line 37@39-2' assembly/'Pipe #4 input at line 37@39-2'::@_instance
+    IL_018e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!4,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupJoin<string,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,string,class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>,
+                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Collections.Generic.IEnumerable`1<!!2>,!!4>>)
+    IL_0193:  ldloc.s    V_7
+    IL_0195:  newobj     instance void assembly/'Pipe #4 input at line 37@39-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_019a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_019f:  ldsfld     class assembly/'Pipe #4 input at line 37@42-5' assembly/'Pipe #4 input at line 37@42-5'::@_instance
+    IL_01a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`4<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product,string>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,string>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01a9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,string>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_01ae:  stloc.s    V_6
+    IL_01b0:  ldloc.s    V_6
+    IL_01b2:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,string>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01b7:  stsfld     class [runtime]System.Tuple`2<string,string>[] assembly::q4@36
+    IL_01bc:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          categories()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categories()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Tuple`2<string,string>[]
+          q()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,string>[] assembly::get_q()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[]
+          q2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>[] assembly::get_q2()
+  } 
+  .property class [runtime]System.Tuple`2<string,string>[]
+          q3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,string>[] assembly::get_q3()
+  } 
+  .property class [runtime]System.Tuple`2<string,string>[]
+          q4()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,string>[] assembly::get_q4()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOff.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOff.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOff.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOff.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOff.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOff.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOn.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOn.il.net472.debug.bsl
new file mode 100644
index 00000000000..747c16cfd99
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOn.il.net472.debug.bsl
@@ -0,0 +1,1874 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 10@11'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #1 input at line 10@11'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/'Pipe #1 input at line 10@11'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/'Pipe #1 input at line 10@11'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #1 input at line 10@11'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #1 input at line 10@11'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 10@11'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                                int32,
+                                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 10@12-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 10@12-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 10@12-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 10@12-1' assembly/'Pipe #1 input at line 10@12-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #2 input at line 17@18'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #2 input at line 17@18'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/'Pipe #2 input at line 17@18'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/'Pipe #2 input at line 17@18'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #2 input at line 17@18'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #2 input at line 17@18'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #2 input at line 17@18'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                                int32,
+                                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 17@19-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 17@19-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 17@19-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 17@19-1' assembly/'Pipe #2 input at line 17@19-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 25@26'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 25@26'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 25@26'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 25@27-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 25@27-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 25@27-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 25@27-1' assembly/'Pipe #3 input at line 25@27-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 25@28-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 25@28-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 25@28-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 25@28-2' assembly/'Pipe #3 input at line 25@28-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #4 input at line 43@44'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #4 input at line 43@44'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                                int32,
+                                                                                                class [Utils]Utils/Product)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 43@45-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 43@45-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 43@45-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 43@45-1' assembly/'Pipe #4 input at line 43@45-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #5 input at line 51@52'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #5 input at line 51@52'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/'Pipe #5 input at line 51@52'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/'Pipe #5 input at line 51@52'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #5 input at line 51@52'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #5 input at line 51@52'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #5 input at line 51@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                                int32,
+                                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 51@53-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 51@53-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string d) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 51@53-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 51@53-1' assembly/'Pipe #5 input at line 51@53-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 51@54-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 51@54-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string d) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 51@54-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 51@54-2' assembly/'Pipe #5 input at line 51@54-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@60'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 59@60'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 59@60'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@61-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@61-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@61-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@61-1' assembly/'Pipe #6 input at line 59@61-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@62-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@62-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@62-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@62-2' assembly/'Pipe #6 input at line 59@62-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@63-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@63-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@63-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@63-3' assembly/'Pipe #6 input at line 59@63-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> sortedWords@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> sortedWords2@16
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@23
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Product[] sortedProducts@24
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Product[] sortedProducts2@42
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> digits@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> sortedDigits@50
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Product[] sortedProducts3@58
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_sortedWords() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedWords@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_sortedWords2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedWords2@16
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@23
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Product[] get_sortedProducts() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Product[] assembly::sortedProducts@24
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Product[] get_sortedProducts2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Product[] assembly::sortedProducts2@42
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_digits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@49
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_sortedDigits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedDigits@50
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Product[] get_sortedProducts3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Product[] assembly::sortedProducts3@58
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<string> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_8,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_9,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_10,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_11)
+    IL_0000:  ldstr      "cherry"
+    IL_0005:  ldstr      "apple"
+    IL_000a:  ldstr      "blueberry"
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@8
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_002d:  stloc.1
+    IL_002e:  ldloc.1
+    IL_002f:  ldnull
+    IL_0030:  ldc.i4.0
+    IL_0031:  ldnull
+    IL_0032:  newobj     instance void assembly/'Pipe #1 input at line 10@11'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                              int32,
+                                                                                              string)
+    IL_0037:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_003c:  ldsfld     class assembly/'Pipe #1 input at line 10@12-1' assembly/'Pipe #1 input at line 10@12-1'::@_instance
+    IL_0041:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<string,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0046:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_004b:  stloc.0
+    IL_004c:  ldloc.0
+    IL_004d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0052:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedWords@9
+    IL_0057:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_005c:  stloc.3
+    IL_005d:  ldloc.3
+    IL_005e:  ldnull
+    IL_005f:  ldc.i4.0
+    IL_0060:  ldnull
+    IL_0061:  newobj     instance void assembly/'Pipe #2 input at line 17@18'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                              int32,
+                                                                                              string)
+    IL_0066:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_006b:  ldsfld     class assembly/'Pipe #2 input at line 17@19-1' assembly/'Pipe #2 input at line 17@19-1'::@_instance
+    IL_0070:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<string,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0075:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_007a:  stloc.2
+    IL_007b:  ldloc.2
+    IL_007c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0081:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedWords2@16
+    IL_0086:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_008b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@23
+    IL_0090:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0095:  stloc.s    V_5
+    IL_0097:  ldloc.s    V_5
+    IL_0099:  ldloc.s    V_5
+    IL_009b:  ldloc.s    V_5
+    IL_009d:  ldloc.s    V_5
+    IL_009f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_00a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00a9:  ldloc.s    V_5
+    IL_00ab:  newobj     instance void assembly/'Pipe #3 input at line 25@26'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00b0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00b5:  ldsfld     class assembly/'Pipe #3 input at line 25@27-1' assembly/'Pipe #3 input at line 25@27-1'::@_instance
+    IL_00ba:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00bf:  ldsfld     class assembly/'Pipe #3 input at line 25@28-2' assembly/'Pipe #3 input at line 25@28-2'::@_instance
+    IL_00c4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00c9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00ce:  stloc.s    V_4
+    IL_00d0:  ldloc.s    V_4
+    IL_00d2:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00d7:  stsfld     class [Utils]Utils/Product[] assembly::sortedProducts@24
+    IL_00dc:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00e1:  stloc.s    V_7
+    IL_00e3:  ldloc.s    V_7
+    IL_00e5:  ldnull
+    IL_00e6:  ldc.i4.0
+    IL_00e7:  ldnull
+    IL_00e8:  newobj     instance void assembly/'Pipe #4 input at line 43@44'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                              int32,
+                                                                                              class [Utils]Utils/Product)
+    IL_00ed:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00f2:  ldsfld     class assembly/'Pipe #4 input at line 43@45-1' assembly/'Pipe #4 input at line 43@45-1'::@_instance
+    IL_00f7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortByDescending<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00fc:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0101:  stloc.s    V_6
+    IL_0103:  ldloc.s    V_6
+    IL_0105:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_010a:  stsfld     class [Utils]Utils/Product[] assembly::sortedProducts2@42
+    IL_010f:  ldstr      "zero"
+    IL_0114:  ldstr      "one"
+    IL_0119:  ldstr      "two"
+    IL_011e:  ldstr      "three"
+    IL_0123:  ldstr      "four"
+    IL_0128:  ldstr      "five"
+    IL_012d:  ldstr      "six"
+    IL_0132:  ldstr      "seven"
+    IL_0137:  ldstr      "eight"
+    IL_013c:  ldstr      "nine"
+    IL_0141:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0146:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_014b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0150:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0155:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_015a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_015f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0164:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0169:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_016e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0173:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0178:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@49
+    IL_017d:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0182:  stloc.s    V_9
+    IL_0184:  ldloc.s    V_9
+    IL_0186:  ldloc.s    V_9
+    IL_0188:  ldnull
+    IL_0189:  ldc.i4.0
+    IL_018a:  ldnull
+    IL_018b:  newobj     instance void assembly/'Pipe #5 input at line 51@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                              int32,
+                                                                                              string)
+    IL_0190:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0195:  ldsfld     class assembly/'Pipe #5 input at line 51@53-1' assembly/'Pipe #5 input at line 51@53-1'::@_instance
+    IL_019a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<string,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_019f:  ldsfld     class assembly/'Pipe #5 input at line 51@54-2' assembly/'Pipe #5 input at line 51@54-2'::@_instance
+    IL_01a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::ThenBy<string,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01a9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_01ae:  stloc.s    V_8
+    IL_01b0:  ldloc.s    V_8
+    IL_01b2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01b7:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedDigits@50
+    IL_01bc:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_01c1:  stloc.s    V_11
+    IL_01c3:  ldloc.s    V_11
+    IL_01c5:  ldloc.s    V_11
+    IL_01c7:  ldloc.s    V_11
+    IL_01c9:  ldloc.s    V_11
+    IL_01cb:  ldloc.s    V_11
+    IL_01cd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_01d2:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01d7:  ldloc.s    V_11
+    IL_01d9:  newobj     instance void assembly/'Pipe #6 input at line 59@60'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01de:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01e3:  ldsfld     class assembly/'Pipe #6 input at line 59@61-1' assembly/'Pipe #6 input at line 59@61-1'::@_instance
+    IL_01e8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01ed:  ldsfld     class assembly/'Pipe #6 input at line 59@62-2' assembly/'Pipe #6 input at line 59@62-2'::@_instance
+    IL_01f2:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::ThenByDescending<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,valuetype [runtime]System.Decimal>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01f7:  ldsfld     class assembly/'Pipe #6 input at line 59@63-3' assembly/'Pipe #6 input at line 59@63-3'::@_instance
+    IL_01fc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0201:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0206:  stloc.s    V_10
+    IL_0208:  ldloc.s    V_10
+    IL_020a:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_020f:  stsfld     class [Utils]Utils/Product[] assembly::sortedProducts3@58
+    IL_0214:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          sortedWords()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_sortedWords()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          sortedWords2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_sortedWords2()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [Utils]Utils/Product[] sortedProducts()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Product[] assembly::get_sortedProducts()
+  } 
+  .property class [Utils]Utils/Product[] sortedProducts2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Product[] assembly::get_sortedProducts2()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          digits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          sortedDigits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_sortedDigits()
+  } 
+  .property class [Utils]Utils/Product[] sortedProducts3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Product[] assembly::get_sortedProducts3()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOn.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOn.il.net472.release.bsl
new file mode 100644
index 00000000000..747c16cfd99
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOn.il.net472.release.bsl
@@ -0,0 +1,1874 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 10@11'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #1 input at line 10@11'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/'Pipe #1 input at line 10@11'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/'Pipe #1 input at line 10@11'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #1 input at line 10@11'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #1 input at line 10@11'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 10@11'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                                int32,
+                                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 10@12-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 10@12-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 10@12-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 10@12-1' assembly/'Pipe #1 input at line 10@12-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #2 input at line 17@18'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #2 input at line 17@18'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/'Pipe #2 input at line 17@18'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/'Pipe #2 input at line 17@18'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #2 input at line 17@18'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #2 input at line 17@18'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #2 input at line 17@18'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                                int32,
+                                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 17@19-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 17@19-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 17@19-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 17@19-1' assembly/'Pipe #2 input at line 17@19-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 25@26'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 25@26'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 25@26'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 25@27-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 25@27-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 25@27-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 25@27-1' assembly/'Pipe #3 input at line 25@27-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 25@28-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 25@28-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 25@28-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 25@28-2' assembly/'Pipe #3 input at line 25@28-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #4 input at line 43@44'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #4 input at line 43@44'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                                int32,
+                                                                                                class [Utils]Utils/Product)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 43@45-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 43@45-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 43@45-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 43@45-1' assembly/'Pipe #4 input at line 43@45-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #5 input at line 51@52'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #5 input at line 51@52'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/'Pipe #5 input at line 51@52'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/'Pipe #5 input at line 51@52'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #5 input at line 51@52'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #5 input at line 51@52'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #5 input at line 51@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                                int32,
+                                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 51@53-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 51@53-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string d) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 51@53-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 51@53-1' assembly/'Pipe #5 input at line 51@53-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 51@54-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 51@54-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string d) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 51@54-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 51@54-2' assembly/'Pipe #5 input at line 51@54-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@60'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 59@60'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 59@60'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@61-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@61-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@61-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@61-1' assembly/'Pipe #6 input at line 59@61-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@62-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@62-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@62-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@62-2' assembly/'Pipe #6 input at line 59@62-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@63-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@63-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@63-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@63-3' assembly/'Pipe #6 input at line 59@63-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> sortedWords@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> sortedWords2@16
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@23
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Product[] sortedProducts@24
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Product[] sortedProducts2@42
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> digits@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> sortedDigits@50
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Product[] sortedProducts3@58
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_sortedWords() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedWords@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_sortedWords2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedWords2@16
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@23
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Product[] get_sortedProducts() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Product[] assembly::sortedProducts@24
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Product[] get_sortedProducts2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Product[] assembly::sortedProducts2@42
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_digits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@49
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_sortedDigits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedDigits@50
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Product[] get_sortedProducts3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Product[] assembly::sortedProducts3@58
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<string> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_8,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_9,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_10,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_11)
+    IL_0000:  ldstr      "cherry"
+    IL_0005:  ldstr      "apple"
+    IL_000a:  ldstr      "blueberry"
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@8
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_002d:  stloc.1
+    IL_002e:  ldloc.1
+    IL_002f:  ldnull
+    IL_0030:  ldc.i4.0
+    IL_0031:  ldnull
+    IL_0032:  newobj     instance void assembly/'Pipe #1 input at line 10@11'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                              int32,
+                                                                                              string)
+    IL_0037:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_003c:  ldsfld     class assembly/'Pipe #1 input at line 10@12-1' assembly/'Pipe #1 input at line 10@12-1'::@_instance
+    IL_0041:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<string,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0046:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_004b:  stloc.0
+    IL_004c:  ldloc.0
+    IL_004d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0052:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedWords@9
+    IL_0057:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_005c:  stloc.3
+    IL_005d:  ldloc.3
+    IL_005e:  ldnull
+    IL_005f:  ldc.i4.0
+    IL_0060:  ldnull
+    IL_0061:  newobj     instance void assembly/'Pipe #2 input at line 17@18'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                              int32,
+                                                                                              string)
+    IL_0066:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_006b:  ldsfld     class assembly/'Pipe #2 input at line 17@19-1' assembly/'Pipe #2 input at line 17@19-1'::@_instance
+    IL_0070:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<string,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0075:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_007a:  stloc.2
+    IL_007b:  ldloc.2
+    IL_007c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0081:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedWords2@16
+    IL_0086:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_008b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@23
+    IL_0090:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0095:  stloc.s    V_5
+    IL_0097:  ldloc.s    V_5
+    IL_0099:  ldloc.s    V_5
+    IL_009b:  ldloc.s    V_5
+    IL_009d:  ldloc.s    V_5
+    IL_009f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_00a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00a9:  ldloc.s    V_5
+    IL_00ab:  newobj     instance void assembly/'Pipe #3 input at line 25@26'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00b0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00b5:  ldsfld     class assembly/'Pipe #3 input at line 25@27-1' assembly/'Pipe #3 input at line 25@27-1'::@_instance
+    IL_00ba:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00bf:  ldsfld     class assembly/'Pipe #3 input at line 25@28-2' assembly/'Pipe #3 input at line 25@28-2'::@_instance
+    IL_00c4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00c9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00ce:  stloc.s    V_4
+    IL_00d0:  ldloc.s    V_4
+    IL_00d2:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00d7:  stsfld     class [Utils]Utils/Product[] assembly::sortedProducts@24
+    IL_00dc:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00e1:  stloc.s    V_7
+    IL_00e3:  ldloc.s    V_7
+    IL_00e5:  ldnull
+    IL_00e6:  ldc.i4.0
+    IL_00e7:  ldnull
+    IL_00e8:  newobj     instance void assembly/'Pipe #4 input at line 43@44'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                              int32,
+                                                                                              class [Utils]Utils/Product)
+    IL_00ed:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00f2:  ldsfld     class assembly/'Pipe #4 input at line 43@45-1' assembly/'Pipe #4 input at line 43@45-1'::@_instance
+    IL_00f7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortByDescending<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00fc:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0101:  stloc.s    V_6
+    IL_0103:  ldloc.s    V_6
+    IL_0105:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_010a:  stsfld     class [Utils]Utils/Product[] assembly::sortedProducts2@42
+    IL_010f:  ldstr      "zero"
+    IL_0114:  ldstr      "one"
+    IL_0119:  ldstr      "two"
+    IL_011e:  ldstr      "three"
+    IL_0123:  ldstr      "four"
+    IL_0128:  ldstr      "five"
+    IL_012d:  ldstr      "six"
+    IL_0132:  ldstr      "seven"
+    IL_0137:  ldstr      "eight"
+    IL_013c:  ldstr      "nine"
+    IL_0141:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0146:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_014b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0150:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0155:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_015a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_015f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0164:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0169:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_016e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0173:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0178:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@49
+    IL_017d:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0182:  stloc.s    V_9
+    IL_0184:  ldloc.s    V_9
+    IL_0186:  ldloc.s    V_9
+    IL_0188:  ldnull
+    IL_0189:  ldc.i4.0
+    IL_018a:  ldnull
+    IL_018b:  newobj     instance void assembly/'Pipe #5 input at line 51@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                              int32,
+                                                                                              string)
+    IL_0190:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0195:  ldsfld     class assembly/'Pipe #5 input at line 51@53-1' assembly/'Pipe #5 input at line 51@53-1'::@_instance
+    IL_019a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<string,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_019f:  ldsfld     class assembly/'Pipe #5 input at line 51@54-2' assembly/'Pipe #5 input at line 51@54-2'::@_instance
+    IL_01a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::ThenBy<string,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01a9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_01ae:  stloc.s    V_8
+    IL_01b0:  ldloc.s    V_8
+    IL_01b2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01b7:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedDigits@50
+    IL_01bc:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_01c1:  stloc.s    V_11
+    IL_01c3:  ldloc.s    V_11
+    IL_01c5:  ldloc.s    V_11
+    IL_01c7:  ldloc.s    V_11
+    IL_01c9:  ldloc.s    V_11
+    IL_01cb:  ldloc.s    V_11
+    IL_01cd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_01d2:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01d7:  ldloc.s    V_11
+    IL_01d9:  newobj     instance void assembly/'Pipe #6 input at line 59@60'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01de:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01e3:  ldsfld     class assembly/'Pipe #6 input at line 59@61-1' assembly/'Pipe #6 input at line 59@61-1'::@_instance
+    IL_01e8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01ed:  ldsfld     class assembly/'Pipe #6 input at line 59@62-2' assembly/'Pipe #6 input at line 59@62-2'::@_instance
+    IL_01f2:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::ThenByDescending<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,valuetype [runtime]System.Decimal>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01f7:  ldsfld     class assembly/'Pipe #6 input at line 59@63-3' assembly/'Pipe #6 input at line 59@63-3'::@_instance
+    IL_01fc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0201:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0206:  stloc.s    V_10
+    IL_0208:  ldloc.s    V_10
+    IL_020a:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_020f:  stsfld     class [Utils]Utils/Product[] assembly::sortedProducts3@58
+    IL_0214:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          sortedWords()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_sortedWords()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          sortedWords2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_sortedWords2()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [Utils]Utils/Product[] sortedProducts()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Product[] assembly::get_sortedProducts()
+  } 
+  .property class [Utils]Utils/Product[] sortedProducts2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Product[] assembly::get_sortedProducts2()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          digits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          sortedDigits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_sortedDigits()
+  } 
+  .property class [Utils]Utils/Product[] sortedProducts3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Product[] assembly::get_sortedProducts3()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOn.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
new file mode 100644
index 00000000000..b3476f7d00d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
@@ -0,0 +1,1874 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 10@11'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #1 input at line 10@11'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/'Pipe #1 input at line 10@11'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/'Pipe #1 input at line 10@11'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #1 input at line 10@11'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #1 input at line 10@11'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 10@11'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                                int32,
+                                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 10@12-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 10@12-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 10@12-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 10@12-1' assembly/'Pipe #1 input at line 10@12-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #2 input at line 17@18'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #2 input at line 17@18'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/'Pipe #2 input at line 17@18'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/'Pipe #2 input at line 17@18'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #2 input at line 17@18'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #2 input at line 17@18'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #2 input at line 17@18'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                                int32,
+                                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 17@19-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 17@19-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 17@19-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 17@19-1' assembly/'Pipe #2 input at line 17@19-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 25@26'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 25@26'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 25@26'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 25@27-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 25@27-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 25@27-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 25@27-1' assembly/'Pipe #3 input at line 25@27-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 25@28-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 25@28-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 25@28-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 25@28-2' assembly/'Pipe #3 input at line 25@28-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #4 input at line 43@44'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #4 input at line 43@44'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                                int32,
+                                                                                                class [Utils]Utils/Product)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 43@45-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 43@45-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 43@45-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 43@45-1' assembly/'Pipe #4 input at line 43@45-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #5 input at line 51@52'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #5 input at line 51@52'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/'Pipe #5 input at line 51@52'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/'Pipe #5 input at line 51@52'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #5 input at line 51@52'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #5 input at line 51@52'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #5 input at line 51@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                                int32,
+                                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 51@53-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 51@53-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string d) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 51@53-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 51@53-1' assembly/'Pipe #5 input at line 51@53-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 51@54-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 51@54-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string d) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 51@54-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 51@54-2' assembly/'Pipe #5 input at line 51@54-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@60'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 59@60'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 59@60'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@61-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@61-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@61-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@61-1' assembly/'Pipe #6 input at line 59@61-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@62-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@62-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@62-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@62-2' assembly/'Pipe #6 input at line 59@62-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@63-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@63-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@63-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@63-3' assembly/'Pipe #6 input at line 59@63-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> sortedWords@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> sortedWords2@16
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@23
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Product[] sortedProducts@24
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Product[] sortedProducts2@42
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> digits@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> sortedDigits@50
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Product[] sortedProducts3@58
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_sortedWords() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedWords@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_sortedWords2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedWords2@16
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@23
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Product[] get_sortedProducts() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Product[] assembly::sortedProducts@24
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Product[] get_sortedProducts2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Product[] assembly::sortedProducts2@42
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_digits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@49
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_sortedDigits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedDigits@50
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Product[] get_sortedProducts3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Product[] assembly::sortedProducts3@58
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<string> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_8,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_9,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_10,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_11)
+    IL_0000:  ldstr      "cherry"
+    IL_0005:  ldstr      "apple"
+    IL_000a:  ldstr      "blueberry"
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@8
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_002d:  stloc.1
+    IL_002e:  ldloc.1
+    IL_002f:  ldnull
+    IL_0030:  ldc.i4.0
+    IL_0031:  ldnull
+    IL_0032:  newobj     instance void assembly/'Pipe #1 input at line 10@11'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                              int32,
+                                                                                              string)
+    IL_0037:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_003c:  ldsfld     class assembly/'Pipe #1 input at line 10@12-1' assembly/'Pipe #1 input at line 10@12-1'::@_instance
+    IL_0041:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<string,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0046:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_004b:  stloc.0
+    IL_004c:  ldloc.0
+    IL_004d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0052:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedWords@9
+    IL_0057:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_005c:  stloc.3
+    IL_005d:  ldloc.3
+    IL_005e:  ldnull
+    IL_005f:  ldc.i4.0
+    IL_0060:  ldnull
+    IL_0061:  newobj     instance void assembly/'Pipe #2 input at line 17@18'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                              int32,
+                                                                                              string)
+    IL_0066:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_006b:  ldsfld     class assembly/'Pipe #2 input at line 17@19-1' assembly/'Pipe #2 input at line 17@19-1'::@_instance
+    IL_0070:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<string,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0075:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_007a:  stloc.2
+    IL_007b:  ldloc.2
+    IL_007c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0081:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedWords2@16
+    IL_0086:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_008b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@23
+    IL_0090:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0095:  stloc.s    V_5
+    IL_0097:  ldloc.s    V_5
+    IL_0099:  ldloc.s    V_5
+    IL_009b:  ldloc.s    V_5
+    IL_009d:  ldloc.s    V_5
+    IL_009f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_00a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00a9:  ldloc.s    V_5
+    IL_00ab:  newobj     instance void assembly/'Pipe #3 input at line 25@26'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00b0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00b5:  ldsfld     class assembly/'Pipe #3 input at line 25@27-1' assembly/'Pipe #3 input at line 25@27-1'::@_instance
+    IL_00ba:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00bf:  ldsfld     class assembly/'Pipe #3 input at line 25@28-2' assembly/'Pipe #3 input at line 25@28-2'::@_instance
+    IL_00c4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00c9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00ce:  stloc.s    V_4
+    IL_00d0:  ldloc.s    V_4
+    IL_00d2:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00d7:  stsfld     class [Utils]Utils/Product[] assembly::sortedProducts@24
+    IL_00dc:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00e1:  stloc.s    V_7
+    IL_00e3:  ldloc.s    V_7
+    IL_00e5:  ldnull
+    IL_00e6:  ldc.i4.0
+    IL_00e7:  ldnull
+    IL_00e8:  newobj     instance void assembly/'Pipe #4 input at line 43@44'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                              int32,
+                                                                                              class [Utils]Utils/Product)
+    IL_00ed:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00f2:  ldsfld     class assembly/'Pipe #4 input at line 43@45-1' assembly/'Pipe #4 input at line 43@45-1'::@_instance
+    IL_00f7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortByDescending<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00fc:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0101:  stloc.s    V_6
+    IL_0103:  ldloc.s    V_6
+    IL_0105:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_010a:  stsfld     class [Utils]Utils/Product[] assembly::sortedProducts2@42
+    IL_010f:  ldstr      "zero"
+    IL_0114:  ldstr      "one"
+    IL_0119:  ldstr      "two"
+    IL_011e:  ldstr      "three"
+    IL_0123:  ldstr      "four"
+    IL_0128:  ldstr      "five"
+    IL_012d:  ldstr      "six"
+    IL_0132:  ldstr      "seven"
+    IL_0137:  ldstr      "eight"
+    IL_013c:  ldstr      "nine"
+    IL_0141:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0146:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_014b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0150:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0155:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_015a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_015f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0164:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0169:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_016e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0173:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0178:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@49
+    IL_017d:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0182:  stloc.s    V_9
+    IL_0184:  ldloc.s    V_9
+    IL_0186:  ldloc.s    V_9
+    IL_0188:  ldnull
+    IL_0189:  ldc.i4.0
+    IL_018a:  ldnull
+    IL_018b:  newobj     instance void assembly/'Pipe #5 input at line 51@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                              int32,
+                                                                                              string)
+    IL_0190:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0195:  ldsfld     class assembly/'Pipe #5 input at line 51@53-1' assembly/'Pipe #5 input at line 51@53-1'::@_instance
+    IL_019a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<string,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_019f:  ldsfld     class assembly/'Pipe #5 input at line 51@54-2' assembly/'Pipe #5 input at line 51@54-2'::@_instance
+    IL_01a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::ThenBy<string,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01a9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_01ae:  stloc.s    V_8
+    IL_01b0:  ldloc.s    V_8
+    IL_01b2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01b7:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedDigits@50
+    IL_01bc:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_01c1:  stloc.s    V_11
+    IL_01c3:  ldloc.s    V_11
+    IL_01c5:  ldloc.s    V_11
+    IL_01c7:  ldloc.s    V_11
+    IL_01c9:  ldloc.s    V_11
+    IL_01cb:  ldloc.s    V_11
+    IL_01cd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_01d2:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01d7:  ldloc.s    V_11
+    IL_01d9:  newobj     instance void assembly/'Pipe #6 input at line 59@60'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01de:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01e3:  ldsfld     class assembly/'Pipe #6 input at line 59@61-1' assembly/'Pipe #6 input at line 59@61-1'::@_instance
+    IL_01e8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01ed:  ldsfld     class assembly/'Pipe #6 input at line 59@62-2' assembly/'Pipe #6 input at line 59@62-2'::@_instance
+    IL_01f2:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::ThenByDescending<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,valuetype [runtime]System.Decimal>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01f7:  ldsfld     class assembly/'Pipe #6 input at line 59@63-3' assembly/'Pipe #6 input at line 59@63-3'::@_instance
+    IL_01fc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0201:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0206:  stloc.s    V_10
+    IL_0208:  ldloc.s    V_10
+    IL_020a:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_020f:  stsfld     class [Utils]Utils/Product[] assembly::sortedProducts3@58
+    IL_0214:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          sortedWords()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_sortedWords()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          sortedWords2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_sortedWords2()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [Utils]Utils/Product[] sortedProducts()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Product[] assembly::get_sortedProducts()
+  } 
+  .property class [Utils]Utils/Product[] sortedProducts2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Product[] assembly::get_sortedProducts2()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          digits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          sortedDigits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_sortedDigits()
+  } 
+  .property class [Utils]Utils/Product[] sortedProducts3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Product[] assembly::get_sortedProducts3()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOn.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOn.il.netcore.release.bsl
new file mode 100644
index 00000000000..b3476f7d00d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Ordering01.fs.RealInternalSignatureOn.il.netcore.release.bsl
@@ -0,0 +1,1874 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 10@11'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #1 input at line 10@11'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/'Pipe #1 input at line 10@11'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/'Pipe #1 input at line 10@11'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #1 input at line 10@11'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #1 input at line 10@11'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 10@11'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #1 input at line 10@11'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 10@11'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                                int32,
+                                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 10@12-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 10@12-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 10@12-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 10@12-1' assembly/'Pipe #1 input at line 10@12-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #2 input at line 17@18'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #2 input at line 17@18'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/'Pipe #2 input at line 17@18'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/'Pipe #2 input at line 17@18'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #2 input at line 17@18'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #2 input at line 17@18'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 17@18'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #2 input at line 17@18'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #2 input at line 17@18'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                                int32,
+                                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 17@19-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 17@19-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 17@19-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 17@19-1' assembly/'Pipe #2 input at line 17@19-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 25@26'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 25@26'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #3 input at line 25@26'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 25@27-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 25@27-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 25@27-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 25@27-1' assembly/'Pipe #3 input at line 25@27-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 25@28-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 25@28-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 25@28-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 25@28-2' assembly/'Pipe #3 input at line 25@28-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #4 input at line 43@44'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Product current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [Utils]Utils/Product current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [Utils]Utils/Product>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0,
+               class [Utils]Utils/Product V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #4 input at line 43@44'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 43@44'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [Utils]Utils/Product assembly/'Pipe #4 input at line 43@44'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #4 input at line 43@44'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                                int32,
+                                                                                                class [Utils]Utils/Product)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 43@45-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 43@45-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 43@45-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 43@45-1' assembly/'Pipe #4 input at line 43@45-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #5 input at line 51@52'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #5 input at line 51@52'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/'Pipe #5 input at line 51@52'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/'Pipe #5 input at line 51@52'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #5 input at line 51@52'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #5 input at line 51@52'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@52'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #5 input at line 51@52'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #5 input at line 51@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                                int32,
+                                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 51@53-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 51@53-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(string d) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 51@53-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 51@53-1' assembly/'Pipe #5 input at line 51@53-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 51@54-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 51@54-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(string d) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 51@54-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 51@54-2' assembly/'Pipe #5 input at line 51@54-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@60'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 59@60'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 59@60'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@61-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@61-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@61-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@61-1' assembly/'Pipe #6 input at line 59@61-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@62-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@62-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,valuetype [runtime]System.Decimal>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance valuetype [runtime]System.Decimal Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@62-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@62-2' assembly/'Pipe #6 input at line 59@62-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@63-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@63-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@63-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@63-3' assembly/'Pipe #6 input at line 59@63-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> sortedWords@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> sortedWords2@16
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@23
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Product[] sortedProducts@24
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Product[] sortedProducts2@42
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> digits@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> sortedDigits@50
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Product[] sortedProducts3@58
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_sortedWords() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedWords@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_sortedWords2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedWords2@16
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@23
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Product[] get_sortedProducts() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Product[] assembly::sortedProducts@24
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Product[] get_sortedProducts2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Product[] assembly::sortedProducts2@42
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_digits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@49
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_sortedDigits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedDigits@50
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Product[] get_sortedProducts3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Product[] assembly::sortedProducts3@58
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<string> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_8,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_9,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> V_10,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_11)
+    IL_0000:  ldstr      "cherry"
+    IL_0005:  ldstr      "apple"
+    IL_000a:  ldstr      "blueberry"
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@8
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_002d:  stloc.1
+    IL_002e:  ldloc.1
+    IL_002f:  ldnull
+    IL_0030:  ldc.i4.0
+    IL_0031:  ldnull
+    IL_0032:  newobj     instance void assembly/'Pipe #1 input at line 10@11'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                              int32,
+                                                                                              string)
+    IL_0037:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_003c:  ldsfld     class assembly/'Pipe #1 input at line 10@12-1' assembly/'Pipe #1 input at line 10@12-1'::@_instance
+    IL_0041:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<string,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0046:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_004b:  stloc.0
+    IL_004c:  ldloc.0
+    IL_004d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0052:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedWords@9
+    IL_0057:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_005c:  stloc.3
+    IL_005d:  ldloc.3
+    IL_005e:  ldnull
+    IL_005f:  ldc.i4.0
+    IL_0060:  ldnull
+    IL_0061:  newobj     instance void assembly/'Pipe #2 input at line 17@18'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                              int32,
+                                                                                              string)
+    IL_0066:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_006b:  ldsfld     class assembly/'Pipe #2 input at line 17@19-1' assembly/'Pipe #2 input at line 17@19-1'::@_instance
+    IL_0070:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<string,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0075:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_007a:  stloc.2
+    IL_007b:  ldloc.2
+    IL_007c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0081:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedWords2@16
+    IL_0086:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_008b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@23
+    IL_0090:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0095:  stloc.s    V_5
+    IL_0097:  ldloc.s    V_5
+    IL_0099:  ldloc.s    V_5
+    IL_009b:  ldloc.s    V_5
+    IL_009d:  ldloc.s    V_5
+    IL_009f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_00a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00a9:  ldloc.s    V_5
+    IL_00ab:  newobj     instance void assembly/'Pipe #3 input at line 25@26'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00b0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00b5:  ldsfld     class assembly/'Pipe #3 input at line 25@27-1' assembly/'Pipe #3 input at line 25@27-1'::@_instance
+    IL_00ba:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00bf:  ldsfld     class assembly/'Pipe #3 input at line 25@28-2' assembly/'Pipe #3 input at line 25@28-2'::@_instance
+    IL_00c4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00c9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00ce:  stloc.s    V_4
+    IL_00d0:  ldloc.s    V_4
+    IL_00d2:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00d7:  stsfld     class [Utils]Utils/Product[] assembly::sortedProducts@24
+    IL_00dc:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00e1:  stloc.s    V_7
+    IL_00e3:  ldloc.s    V_7
+    IL_00e5:  ldnull
+    IL_00e6:  ldc.i4.0
+    IL_00e7:  ldnull
+    IL_00e8:  newobj     instance void assembly/'Pipe #4 input at line 43@44'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                              int32,
+                                                                                              class [Utils]Utils/Product)
+    IL_00ed:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00f2:  ldsfld     class assembly/'Pipe #4 input at line 43@45-1' assembly/'Pipe #4 input at line 43@45-1'::@_instance
+    IL_00f7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortByDescending<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00fc:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0101:  stloc.s    V_6
+    IL_0103:  ldloc.s    V_6
+    IL_0105:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_010a:  stsfld     class [Utils]Utils/Product[] assembly::sortedProducts2@42
+    IL_010f:  ldstr      "zero"
+    IL_0114:  ldstr      "one"
+    IL_0119:  ldstr      "two"
+    IL_011e:  ldstr      "three"
+    IL_0123:  ldstr      "four"
+    IL_0128:  ldstr      "five"
+    IL_012d:  ldstr      "six"
+    IL_0132:  ldstr      "seven"
+    IL_0137:  ldstr      "eight"
+    IL_013c:  ldstr      "nine"
+    IL_0141:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0146:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_014b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0150:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0155:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_015a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_015f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0164:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0169:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_016e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0173:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0178:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@49
+    IL_017d:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0182:  stloc.s    V_9
+    IL_0184:  ldloc.s    V_9
+    IL_0186:  ldloc.s    V_9
+    IL_0188:  ldnull
+    IL_0189:  ldc.i4.0
+    IL_018a:  ldnull
+    IL_018b:  newobj     instance void assembly/'Pipe #5 input at line 51@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                              int32,
+                                                                                              string)
+    IL_0190:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0195:  ldsfld     class assembly/'Pipe #5 input at line 51@53-1' assembly/'Pipe #5 input at line 51@53-1'::@_instance
+    IL_019a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<string,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_019f:  ldsfld     class assembly/'Pipe #5 input at line 51@54-2' assembly/'Pipe #5 input at line 51@54-2'::@_instance
+    IL_01a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::ThenBy<string,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01a9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_01ae:  stloc.s    V_8
+    IL_01b0:  ldloc.s    V_8
+    IL_01b2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01b7:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::sortedDigits@50
+    IL_01bc:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_01c1:  stloc.s    V_11
+    IL_01c3:  ldloc.s    V_11
+    IL_01c5:  ldloc.s    V_11
+    IL_01c7:  ldloc.s    V_11
+    IL_01c9:  ldloc.s    V_11
+    IL_01cb:  ldloc.s    V_11
+    IL_01cd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_01d2:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01d7:  ldloc.s    V_11
+    IL_01d9:  newobj     instance void assembly/'Pipe #6 input at line 59@60'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01de:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01e3:  ldsfld     class assembly/'Pipe #6 input at line 59@61-1' assembly/'Pipe #6 input at line 59@61-1'::@_instance
+    IL_01e8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SortBy<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01ed:  ldsfld     class assembly/'Pipe #6 input at line 59@62-2' assembly/'Pipe #6 input at line 59@62-2'::@_instance
+    IL_01f2:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::ThenByDescending<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,valuetype [runtime]System.Decimal>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01f7:  ldsfld     class assembly/'Pipe #6 input at line 59@63-3' assembly/'Pipe #6 input at line 59@63-3'::@_instance
+    IL_01fc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0201:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0206:  stloc.s    V_10
+    IL_0208:  ldloc.s    V_10
+    IL_020a:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_020f:  stsfld     class [Utils]Utils/Product[] assembly::sortedProducts3@58
+    IL_0214:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          sortedWords()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_sortedWords()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          sortedWords2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_sortedWords2()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [Utils]Utils/Product[] sortedProducts()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Product[] assembly::get_sortedProducts()
+  } 
+  .property class [Utils]Utils/Product[] sortedProducts2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Product[] assembly::get_sortedProducts2()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          digits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          sortedDigits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_sortedDigits()
+  } 
+  .property class [Utils]Utils/Product[] sortedProducts3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Product[] assembly::get_sortedProducts3()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOff.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOff.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOff.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOff.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOff.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOff.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOn.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOn.il.net472.debug.bsl
new file mode 100644
index 00000000000..afbad574fbe
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOn.il.net472.debug.bsl
@@ -0,0 +1,1887 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 11@12'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 11@12'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 19@21-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@21-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'Pipe #2 input at line 19@21-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@21-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'Pipe #2 input at line 19@21-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                     !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 19@20'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@20'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@20'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@20'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@20'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'Pipe #2 input at line 19@21-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                      class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 19@22-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 19@22-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_Region()
+      IL_0014:  ldstr      "WA"
+      IL_0019:  call       bool [netstandard]System.String::Equals(string,
+                                                                   string)
+      IL_001e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 19@22-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 19@22-2' assembly/'Pipe #2 input at line 19@22-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 19@23-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 19@23-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>::.ctor(!0,
+                                                                                                                                 !1,
+                                                                                                                                 !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 19@23-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 19@23-3' assembly/'Pipe #2 input at line 19@23-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #3 input at line 28@29'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #3 input at line 28@29'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 35@37-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@37-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'Pipe #4 input at line 35@37-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@37-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'Pipe #4 input at line 35@37-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                     !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 35@36'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@36'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@36'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@36'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@36'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'Pipe #4 input at line 35@37-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                      class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 35@38-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 35@38-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_Region()
+      IL_0014:  ldstr      "WA"
+      IL_0019:  call       bool [netstandard]System.String::Equals(string,
+                                                                   string)
+      IL_001e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 35@38-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 35@38-2' assembly/'Pipe #4 input at line 35@38-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 35@39-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 35@39-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>::.ctor(!0,
+                                                                                                                                 !1,
+                                                                                                                                 !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 35@39-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 35@39-3' assembly/'Pipe #4 input at line 35@39-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #5 input at line 44@45'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #5 input at line 44@45'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 44@46-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 44@46-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.6
+      IL_0002:  clt
+      IL_0004:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 44@46-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 44@46-1' assembly/'Pipe #5 input at line 44@46-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #6 input at line 51@52'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #6 input at line 51@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 51@53-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 51@53-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.3
+      IL_0002:  rem
+      IL_0003:  ldc.i4.0
+      IL_0004:  ceq
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 51@53-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 51@53-1' assembly/'Pipe #6 input at line 51@53-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> first3Numbers@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] WAOrders@18
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> allButFirst4Numbers@27
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> WAOrders2@34
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> firstNumbersLessThan6@43
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> allButFirst3Numbers@50
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@7
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_first3Numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::first3Numbers@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@17
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] get_WAOrders() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::WAOrders@18
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_allButFirst4Numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::allButFirst4Numbers@27
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> get_WAOrders2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> assembly::WAOrders2@34
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_firstNumbersLessThan6() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::firstNumbersLessThan6@43
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_allButFirst3Numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::allButFirst3Numbers@50
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> V_8,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_9,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_10,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_11,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_12)
+    IL_0000:  ldc.i4.5
+    IL_0001:  ldc.i4.4
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.3
+    IL_0004:  ldc.i4.s   9
+    IL_0006:  ldc.i4.8
+    IL_0007:  ldc.i4.6
+    IL_0008:  ldc.i4.7
+    IL_0009:  ldc.i4.2
+    IL_000a:  ldc.i4.0
+    IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0010:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0015:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0024:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0029:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0033:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_003d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0042:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@7
+    IL_0047:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_004c:  stloc.1
+    IL_004d:  ldloc.1
+    IL_004e:  ldnull
+    IL_004f:  ldc.i4.0
+    IL_0050:  ldc.i4.0
+    IL_0051:  newobj     instance void assembly/'Pipe #1 input at line 11@12'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_0056:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_005b:  ldc.i4.3
+    IL_005c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Take<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                              int32)
+    IL_0061:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0066:  stloc.0
+    IL_0067:  ldloc.0
+    IL_0068:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_006d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::first3Numbers@10
+    IL_0072:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_0077:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@17
+    IL_007c:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0081:  stloc.3
+    IL_0082:  ldloc.3
+    IL_0083:  ldloc.3
+    IL_0084:  ldloc.3
+    IL_0085:  ldloc.3
+    IL_0086:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_008b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0090:  ldloc.3
+    IL_0091:  newobj     instance void assembly/'Pipe #2 input at line 19@20'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0096:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_009b:  ldsfld     class assembly/'Pipe #2 input at line 19@22-2' assembly/'Pipe #2 input at line 19@22-2'::@_instance
+    IL_00a0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00a5:  ldsfld     class assembly/'Pipe #2 input at line 19@23-3' assembly/'Pipe #2 input at line 19@23-3'::@_instance
+    IL_00aa:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00af:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00b4:  stloc.2
+    IL_00b5:  ldloc.2
+    IL_00b6:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00bb:  stsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::WAOrders@18
+    IL_00c0:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00c5:  stloc.s    V_5
+    IL_00c7:  ldloc.s    V_5
+    IL_00c9:  ldnull
+    IL_00ca:  ldc.i4.0
+    IL_00cb:  ldc.i4.0
+    IL_00cc:  newobj     instance void assembly/'Pipe #3 input at line 28@29'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_00d1:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00d6:  ldc.i4.4
+    IL_00d7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Skip<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                              int32)
+    IL_00dc:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00e1:  stloc.s    V_4
+    IL_00e3:  ldloc.s    V_4
+    IL_00e5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00ea:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::allButFirst4Numbers@27
+    IL_00ef:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00f4:  stloc.s    V_7
+    IL_00f6:  ldloc.s    V_7
+    IL_00f8:  ldloc.s    V_7
+    IL_00fa:  ldloc.s    V_7
+    IL_00fc:  ldloc.s    V_7
+    IL_00fe:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_0103:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0108:  ldloc.s    V_7
+    IL_010a:  newobj     instance void assembly/'Pipe #4 input at line 35@36'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_010f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0114:  ldsfld     class assembly/'Pipe #4 input at line 35@38-2' assembly/'Pipe #4 input at line 35@38-2'::@_instance
+    IL_0119:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_011e:  ldsfld     class assembly/'Pipe #4 input at line 35@39-3' assembly/'Pipe #4 input at line 35@39-3'::@_instance
+    IL_0123:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0128:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_012d:  stloc.s    V_6
+    IL_012f:  ldc.i4.2
+    IL_0130:  ldloc.s    V_6
+    IL_0132:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Skip<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(int32,
+                                                                                                                                                                                                                                   class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0137:  stloc.s    V_8
+    IL_0139:  ldloc.s    V_8
+    IL_013b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0140:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> assembly::WAOrders2@34
+    IL_0145:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_014a:  stloc.s    V_10
+    IL_014c:  ldloc.s    V_10
+    IL_014e:  ldnull
+    IL_014f:  ldc.i4.0
+    IL_0150:  ldc.i4.0
+    IL_0151:  newobj     instance void assembly/'Pipe #5 input at line 44@45'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_0156:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_015b:  ldsfld     class assembly/'Pipe #5 input at line 44@46-1' assembly/'Pipe #5 input at line 44@46-1'::@_instance
+    IL_0160:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::TakeWhile<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0165:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_016a:  stloc.s    V_9
+    IL_016c:  ldloc.s    V_9
+    IL_016e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0173:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::firstNumbersLessThan6@43
+    IL_0178:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_017d:  stloc.s    V_12
+    IL_017f:  ldloc.s    V_12
+    IL_0181:  ldnull
+    IL_0182:  ldc.i4.0
+    IL_0183:  ldc.i4.0
+    IL_0184:  newobj     instance void assembly/'Pipe #6 input at line 51@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_0189:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_018e:  ldsfld     class assembly/'Pipe #6 input at line 51@53-1' assembly/'Pipe #6 input at line 51@53-1'::@_instance
+    IL_0193:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SkipWhile<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0198:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_019d:  stloc.s    V_11
+    IL_019f:  ldloc.s    V_11
+    IL_01a1:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01a6:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::allButFirst3Numbers@50
+    IL_01ab:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          first3Numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_first3Numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[]
+          WAOrders()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::get_WAOrders()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          allButFirst4Numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_allButFirst4Numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>
+          WAOrders2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> assembly::get_WAOrders2()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          firstNumbersLessThan6()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_firstNumbersLessThan6()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          allButFirst3Numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_allButFirst3Numbers()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOn.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOn.il.net472.release.bsl
new file mode 100644
index 00000000000..afbad574fbe
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOn.il.net472.release.bsl
@@ -0,0 +1,1887 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 11@12'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 11@12'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 19@21-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@21-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'Pipe #2 input at line 19@21-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@21-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'Pipe #2 input at line 19@21-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                     !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 19@20'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@20'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@20'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@20'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@20'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'Pipe #2 input at line 19@21-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                      class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 19@22-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 19@22-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_Region()
+      IL_0014:  ldstr      "WA"
+      IL_0019:  call       bool [netstandard]System.String::Equals(string,
+                                                                   string)
+      IL_001e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 19@22-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 19@22-2' assembly/'Pipe #2 input at line 19@22-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 19@23-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 19@23-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>::.ctor(!0,
+                                                                                                                                 !1,
+                                                                                                                                 !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 19@23-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 19@23-3' assembly/'Pipe #2 input at line 19@23-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #3 input at line 28@29'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #3 input at line 28@29'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 35@37-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@37-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'Pipe #4 input at line 35@37-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@37-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'Pipe #4 input at line 35@37-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                     !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 35@36'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@36'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@36'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@36'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@36'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'Pipe #4 input at line 35@37-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                      class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 35@38-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 35@38-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_Region()
+      IL_0014:  ldstr      "WA"
+      IL_0019:  call       bool [netstandard]System.String::Equals(string,
+                                                                   string)
+      IL_001e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 35@38-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 35@38-2' assembly/'Pipe #4 input at line 35@38-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 35@39-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 35@39-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>::.ctor(!0,
+                                                                                                                                 !1,
+                                                                                                                                 !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 35@39-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 35@39-3' assembly/'Pipe #4 input at line 35@39-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #5 input at line 44@45'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #5 input at line 44@45'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 44@46-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 44@46-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.6
+      IL_0002:  clt
+      IL_0004:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 44@46-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 44@46-1' assembly/'Pipe #5 input at line 44@46-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #6 input at line 51@52'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #6 input at line 51@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 51@53-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 51@53-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.3
+      IL_0002:  rem
+      IL_0003:  ldc.i4.0
+      IL_0004:  ceq
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 51@53-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 51@53-1' assembly/'Pipe #6 input at line 51@53-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> first3Numbers@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] WAOrders@18
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> allButFirst4Numbers@27
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> WAOrders2@34
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> firstNumbersLessThan6@43
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> allButFirst3Numbers@50
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@7
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_first3Numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::first3Numbers@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@17
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] get_WAOrders() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::WAOrders@18
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_allButFirst4Numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::allButFirst4Numbers@27
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> get_WAOrders2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> assembly::WAOrders2@34
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_firstNumbersLessThan6() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::firstNumbersLessThan6@43
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_allButFirst3Numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::allButFirst3Numbers@50
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> V_8,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_9,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_10,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_11,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_12)
+    IL_0000:  ldc.i4.5
+    IL_0001:  ldc.i4.4
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.3
+    IL_0004:  ldc.i4.s   9
+    IL_0006:  ldc.i4.8
+    IL_0007:  ldc.i4.6
+    IL_0008:  ldc.i4.7
+    IL_0009:  ldc.i4.2
+    IL_000a:  ldc.i4.0
+    IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0010:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0015:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0024:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0029:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0033:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_003d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0042:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@7
+    IL_0047:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_004c:  stloc.1
+    IL_004d:  ldloc.1
+    IL_004e:  ldnull
+    IL_004f:  ldc.i4.0
+    IL_0050:  ldc.i4.0
+    IL_0051:  newobj     instance void assembly/'Pipe #1 input at line 11@12'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_0056:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_005b:  ldc.i4.3
+    IL_005c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Take<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                              int32)
+    IL_0061:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0066:  stloc.0
+    IL_0067:  ldloc.0
+    IL_0068:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_006d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::first3Numbers@10
+    IL_0072:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_0077:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@17
+    IL_007c:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0081:  stloc.3
+    IL_0082:  ldloc.3
+    IL_0083:  ldloc.3
+    IL_0084:  ldloc.3
+    IL_0085:  ldloc.3
+    IL_0086:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_008b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0090:  ldloc.3
+    IL_0091:  newobj     instance void assembly/'Pipe #2 input at line 19@20'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0096:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_009b:  ldsfld     class assembly/'Pipe #2 input at line 19@22-2' assembly/'Pipe #2 input at line 19@22-2'::@_instance
+    IL_00a0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00a5:  ldsfld     class assembly/'Pipe #2 input at line 19@23-3' assembly/'Pipe #2 input at line 19@23-3'::@_instance
+    IL_00aa:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00af:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00b4:  stloc.2
+    IL_00b5:  ldloc.2
+    IL_00b6:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00bb:  stsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::WAOrders@18
+    IL_00c0:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00c5:  stloc.s    V_5
+    IL_00c7:  ldloc.s    V_5
+    IL_00c9:  ldnull
+    IL_00ca:  ldc.i4.0
+    IL_00cb:  ldc.i4.0
+    IL_00cc:  newobj     instance void assembly/'Pipe #3 input at line 28@29'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_00d1:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00d6:  ldc.i4.4
+    IL_00d7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Skip<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                              int32)
+    IL_00dc:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00e1:  stloc.s    V_4
+    IL_00e3:  ldloc.s    V_4
+    IL_00e5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00ea:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::allButFirst4Numbers@27
+    IL_00ef:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00f4:  stloc.s    V_7
+    IL_00f6:  ldloc.s    V_7
+    IL_00f8:  ldloc.s    V_7
+    IL_00fa:  ldloc.s    V_7
+    IL_00fc:  ldloc.s    V_7
+    IL_00fe:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_0103:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0108:  ldloc.s    V_7
+    IL_010a:  newobj     instance void assembly/'Pipe #4 input at line 35@36'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_010f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0114:  ldsfld     class assembly/'Pipe #4 input at line 35@38-2' assembly/'Pipe #4 input at line 35@38-2'::@_instance
+    IL_0119:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_011e:  ldsfld     class assembly/'Pipe #4 input at line 35@39-3' assembly/'Pipe #4 input at line 35@39-3'::@_instance
+    IL_0123:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0128:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_012d:  stloc.s    V_6
+    IL_012f:  ldc.i4.2
+    IL_0130:  ldloc.s    V_6
+    IL_0132:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Skip<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(int32,
+                                                                                                                                                                                                                                   class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0137:  stloc.s    V_8
+    IL_0139:  ldloc.s    V_8
+    IL_013b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0140:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> assembly::WAOrders2@34
+    IL_0145:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_014a:  stloc.s    V_10
+    IL_014c:  ldloc.s    V_10
+    IL_014e:  ldnull
+    IL_014f:  ldc.i4.0
+    IL_0150:  ldc.i4.0
+    IL_0151:  newobj     instance void assembly/'Pipe #5 input at line 44@45'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_0156:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_015b:  ldsfld     class assembly/'Pipe #5 input at line 44@46-1' assembly/'Pipe #5 input at line 44@46-1'::@_instance
+    IL_0160:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::TakeWhile<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0165:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_016a:  stloc.s    V_9
+    IL_016c:  ldloc.s    V_9
+    IL_016e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0173:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::firstNumbersLessThan6@43
+    IL_0178:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_017d:  stloc.s    V_12
+    IL_017f:  ldloc.s    V_12
+    IL_0181:  ldnull
+    IL_0182:  ldc.i4.0
+    IL_0183:  ldc.i4.0
+    IL_0184:  newobj     instance void assembly/'Pipe #6 input at line 51@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_0189:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_018e:  ldsfld     class assembly/'Pipe #6 input at line 51@53-1' assembly/'Pipe #6 input at line 51@53-1'::@_instance
+    IL_0193:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SkipWhile<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0198:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_019d:  stloc.s    V_11
+    IL_019f:  ldloc.s    V_11
+    IL_01a1:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01a6:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::allButFirst3Numbers@50
+    IL_01ab:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          first3Numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_first3Numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[]
+          WAOrders()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::get_WAOrders()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          allButFirst4Numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_allButFirst4Numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>
+          WAOrders2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> assembly::get_WAOrders2()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          firstNumbersLessThan6()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_firstNumbersLessThan6()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          allButFirst3Numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_allButFirst3Numbers()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOn.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
new file mode 100644
index 00000000000..5e10bfe4ec9
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
@@ -0,0 +1,1887 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 11@12'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 11@12'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 19@21-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@21-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'Pipe #2 input at line 19@21-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@21-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'Pipe #2 input at line 19@21-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                           !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 19@20'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@20'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@20'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@20'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@20'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'Pipe #2 input at line 19@21-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                      class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 19@22-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 19@22-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_Region()
+      IL_0014:  ldstr      "WA"
+      IL_0019:  call       bool [netstandard]System.String::Equals(string,
+                                                                   string)
+      IL_001e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 19@22-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 19@22-2' assembly/'Pipe #2 input at line 19@22-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 19@23-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 19@23-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>::.ctor(!0,
+                                                                                                                                             !1,
+                                                                                                                                             !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 19@23-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 19@23-3' assembly/'Pipe #2 input at line 19@23-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #3 input at line 28@29'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #3 input at line 28@29'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 35@37-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@37-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'Pipe #4 input at line 35@37-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@37-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'Pipe #4 input at line 35@37-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                           !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 35@36'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@36'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@36'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@36'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@36'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'Pipe #4 input at line 35@37-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                      class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 35@38-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 35@38-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_Region()
+      IL_0014:  ldstr      "WA"
+      IL_0019:  call       bool [netstandard]System.String::Equals(string,
+                                                                   string)
+      IL_001e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 35@38-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 35@38-2' assembly/'Pipe #4 input at line 35@38-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 35@39-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 35@39-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>::.ctor(!0,
+                                                                                                                                             !1,
+                                                                                                                                             !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 35@39-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 35@39-3' assembly/'Pipe #4 input at line 35@39-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #5 input at line 44@45'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #5 input at line 44@45'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 44@46-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 44@46-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.6
+      IL_0002:  clt
+      IL_0004:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 44@46-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 44@46-1' assembly/'Pipe #5 input at line 44@46-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #6 input at line 51@52'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #6 input at line 51@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 51@53-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 51@53-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.3
+      IL_0002:  rem
+      IL_0003:  ldc.i4.0
+      IL_0004:  ceq
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 51@53-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 51@53-1' assembly/'Pipe #6 input at line 51@53-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> first3Numbers@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] WAOrders@18
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> allButFirst4Numbers@27
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> WAOrders2@34
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> firstNumbersLessThan6@43
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> allButFirst3Numbers@50
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@7
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_first3Numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::first3Numbers@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@17
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] get_WAOrders() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::WAOrders@18
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_allButFirst4Numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::allButFirst4Numbers@27
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> get_WAOrders2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> assembly::WAOrders2@34
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_firstNumbersLessThan6() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::firstNumbersLessThan6@43
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_allButFirst3Numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::allButFirst3Numbers@50
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> V_8,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_9,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_10,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_11,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_12)
+    IL_0000:  ldc.i4.5
+    IL_0001:  ldc.i4.4
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.3
+    IL_0004:  ldc.i4.s   9
+    IL_0006:  ldc.i4.8
+    IL_0007:  ldc.i4.6
+    IL_0008:  ldc.i4.7
+    IL_0009:  ldc.i4.2
+    IL_000a:  ldc.i4.0
+    IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0010:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0015:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0024:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0029:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0033:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_003d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0042:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@7
+    IL_0047:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_004c:  stloc.1
+    IL_004d:  ldloc.1
+    IL_004e:  ldnull
+    IL_004f:  ldc.i4.0
+    IL_0050:  ldc.i4.0
+    IL_0051:  newobj     instance void assembly/'Pipe #1 input at line 11@12'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_0056:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_005b:  ldc.i4.3
+    IL_005c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Take<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                    int32)
+    IL_0061:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0066:  stloc.0
+    IL_0067:  ldloc.0
+    IL_0068:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_006d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::first3Numbers@10
+    IL_0072:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_0077:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@17
+    IL_007c:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0081:  stloc.3
+    IL_0082:  ldloc.3
+    IL_0083:  ldloc.3
+    IL_0084:  ldloc.3
+    IL_0085:  ldloc.3
+    IL_0086:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_008b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0090:  ldloc.3
+    IL_0091:  newobj     instance void assembly/'Pipe #2 input at line 19@20'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0096:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_009b:  ldsfld     class assembly/'Pipe #2 input at line 19@22-2' assembly/'Pipe #2 input at line 19@22-2'::@_instance
+    IL_00a0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00a5:  ldsfld     class assembly/'Pipe #2 input at line 19@23-3' assembly/'Pipe #2 input at line 19@23-3'::@_instance
+    IL_00aa:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00af:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00b4:  stloc.2
+    IL_00b5:  ldloc.2
+    IL_00b6:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00bb:  stsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::WAOrders@18
+    IL_00c0:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00c5:  stloc.s    V_5
+    IL_00c7:  ldloc.s    V_5
+    IL_00c9:  ldnull
+    IL_00ca:  ldc.i4.0
+    IL_00cb:  ldc.i4.0
+    IL_00cc:  newobj     instance void assembly/'Pipe #3 input at line 28@29'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_00d1:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00d6:  ldc.i4.4
+    IL_00d7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Skip<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                    int32)
+    IL_00dc:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00e1:  stloc.s    V_4
+    IL_00e3:  ldloc.s    V_4
+    IL_00e5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00ea:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::allButFirst4Numbers@27
+    IL_00ef:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00f4:  stloc.s    V_7
+    IL_00f6:  ldloc.s    V_7
+    IL_00f8:  ldloc.s    V_7
+    IL_00fa:  ldloc.s    V_7
+    IL_00fc:  ldloc.s    V_7
+    IL_00fe:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_0103:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0108:  ldloc.s    V_7
+    IL_010a:  newobj     instance void assembly/'Pipe #4 input at line 35@36'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_010f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0114:  ldsfld     class assembly/'Pipe #4 input at line 35@38-2' assembly/'Pipe #4 input at line 35@38-2'::@_instance
+    IL_0119:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_011e:  ldsfld     class assembly/'Pipe #4 input at line 35@39-3' assembly/'Pipe #4 input at line 35@39-3'::@_instance
+    IL_0123:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0128:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_012d:  stloc.s    V_6
+    IL_012f:  ldc.i4.2
+    IL_0130:  ldloc.s    V_6
+    IL_0132:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Skip<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(int32,
+                                                                                                                                                                                                                                                     class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0137:  stloc.s    V_8
+    IL_0139:  ldloc.s    V_8
+    IL_013b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0140:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> assembly::WAOrders2@34
+    IL_0145:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_014a:  stloc.s    V_10
+    IL_014c:  ldloc.s    V_10
+    IL_014e:  ldnull
+    IL_014f:  ldc.i4.0
+    IL_0150:  ldc.i4.0
+    IL_0151:  newobj     instance void assembly/'Pipe #5 input at line 44@45'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_0156:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_015b:  ldsfld     class assembly/'Pipe #5 input at line 44@46-1' assembly/'Pipe #5 input at line 44@46-1'::@_instance
+    IL_0160:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::TakeWhile<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0165:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_016a:  stloc.s    V_9
+    IL_016c:  ldloc.s    V_9
+    IL_016e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0173:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::firstNumbersLessThan6@43
+    IL_0178:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_017d:  stloc.s    V_12
+    IL_017f:  ldloc.s    V_12
+    IL_0181:  ldnull
+    IL_0182:  ldc.i4.0
+    IL_0183:  ldc.i4.0
+    IL_0184:  newobj     instance void assembly/'Pipe #6 input at line 51@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_0189:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_018e:  ldsfld     class assembly/'Pipe #6 input at line 51@53-1' assembly/'Pipe #6 input at line 51@53-1'::@_instance
+    IL_0193:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SkipWhile<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0198:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_019d:  stloc.s    V_11
+    IL_019f:  ldloc.s    V_11
+    IL_01a1:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01a6:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::allButFirst3Numbers@50
+    IL_01ab:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          first3Numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_first3Numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[]
+          WAOrders()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::get_WAOrders()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          allButFirst4Numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_allButFirst4Numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>
+          WAOrders2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> assembly::get_WAOrders2()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          firstNumbersLessThan6()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_firstNumbersLessThan6()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          allButFirst3Numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_allButFirst3Numbers()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOn.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOn.il.netcore.release.bsl
new file mode 100644
index 00000000000..5e10bfe4ec9
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Partitioning01.fs.RealInternalSignatureOn.il.netcore.release.bsl
@@ -0,0 +1,1887 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 11@12'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@12'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@12'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 11@12'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 19@21-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@21-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'Pipe #2 input at line 19@21-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@21-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'Pipe #2 input at line 19@21-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                           !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 19@20'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@20'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@20'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@20'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 19@20'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'Pipe #2 input at line 19@21-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                      class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 19@22-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 19@22-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_Region()
+      IL_0014:  ldstr      "WA"
+      IL_0019:  call       bool [netstandard]System.String::Equals(string,
+                                                                   string)
+      IL_001e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 19@22-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 19@22-2' assembly/'Pipe #2 input at line 19@22-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 19@23-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 19@23-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>::.ctor(!0,
+                                                                                                                                             !1,
+                                                                                                                                             !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 19@23-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 19@23-3' assembly/'Pipe #2 input at line 19@23-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #3 input at line 28@29'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #3 input at line 28@29'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 28@29'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #3 input at line 28@29'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 35@37-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@37-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'Pipe #4 input at line 35@37-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@37-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'Pipe #4 input at line 35@37-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                           !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 35@36'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@36'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@36'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@36'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #4 input at line 35@36'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'Pipe #4 input at line 35@37-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                      class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 35@38-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 35@38-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_Region()
+      IL_0014:  ldstr      "WA"
+      IL_0019:  call       bool [netstandard]System.String::Equals(string,
+                                                                   string)
+      IL_001e:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 35@38-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 35@38-2' assembly/'Pipe #4 input at line 35@38-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 35@39-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 35@39-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>::.ctor(!0,
+                                                                                                                                             !1,
+                                                                                                                                             !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 35@39-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 35@39-3' assembly/'Pipe #4 input at line 35@39-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #5 input at line 44@45'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #5 input at line 44@45'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 44@45'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #5 input at line 44@45'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 44@46-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 44@46-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.6
+      IL_0002:  clt
+      IL_0004:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 44@46-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 44@46-1' assembly/'Pipe #5 input at line 44@46-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #6 input at line 51@52'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #6 input at line 51@52'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #6 input at line 51@52'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #6 input at line 51@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 51@53-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 51@53-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.3
+      IL_0002:  rem
+      IL_0003:  ldc.i4.0
+      IL_0004:  ceq
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 51@53-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 51@53-1' assembly/'Pipe #6 input at line 51@53-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> first3Numbers@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] WAOrders@18
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> allButFirst4Numbers@27
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> WAOrders2@34
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> firstNumbersLessThan6@43
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> allButFirst3Numbers@50
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@7
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_first3Numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::first3Numbers@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@17
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] get_WAOrders() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::WAOrders@18
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_allButFirst4Numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::allButFirst4Numbers@27
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> get_WAOrders2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> assembly::WAOrders2@34
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_firstNumbersLessThan6() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::firstNumbersLessThan6@43
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_allButFirst3Numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::allButFirst3Numbers@50
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> V_8,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_9,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_10,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_11,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_12)
+    IL_0000:  ldc.i4.5
+    IL_0001:  ldc.i4.4
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.3
+    IL_0004:  ldc.i4.s   9
+    IL_0006:  ldc.i4.8
+    IL_0007:  ldc.i4.6
+    IL_0008:  ldc.i4.7
+    IL_0009:  ldc.i4.2
+    IL_000a:  ldc.i4.0
+    IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0010:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0015:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0024:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0029:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0033:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_003d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0042:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@7
+    IL_0047:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_004c:  stloc.1
+    IL_004d:  ldloc.1
+    IL_004e:  ldnull
+    IL_004f:  ldc.i4.0
+    IL_0050:  ldc.i4.0
+    IL_0051:  newobj     instance void assembly/'Pipe #1 input at line 11@12'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_0056:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_005b:  ldc.i4.3
+    IL_005c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Take<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                    int32)
+    IL_0061:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0066:  stloc.0
+    IL_0067:  ldloc.0
+    IL_0068:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_006d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::first3Numbers@10
+    IL_0072:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_0077:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@17
+    IL_007c:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0081:  stloc.3
+    IL_0082:  ldloc.3
+    IL_0083:  ldloc.3
+    IL_0084:  ldloc.3
+    IL_0085:  ldloc.3
+    IL_0086:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_008b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0090:  ldloc.3
+    IL_0091:  newobj     instance void assembly/'Pipe #2 input at line 19@20'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0096:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_009b:  ldsfld     class assembly/'Pipe #2 input at line 19@22-2' assembly/'Pipe #2 input at line 19@22-2'::@_instance
+    IL_00a0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00a5:  ldsfld     class assembly/'Pipe #2 input at line 19@23-3' assembly/'Pipe #2 input at line 19@23-3'::@_instance
+    IL_00aa:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00af:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00b4:  stloc.2
+    IL_00b5:  ldloc.2
+    IL_00b6:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00bb:  stsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::WAOrders@18
+    IL_00c0:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00c5:  stloc.s    V_5
+    IL_00c7:  ldloc.s    V_5
+    IL_00c9:  ldnull
+    IL_00ca:  ldc.i4.0
+    IL_00cb:  ldc.i4.0
+    IL_00cc:  newobj     instance void assembly/'Pipe #3 input at line 28@29'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_00d1:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_00d6:  ldc.i4.4
+    IL_00d7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Skip<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                    int32)
+    IL_00dc:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00e1:  stloc.s    V_4
+    IL_00e3:  ldloc.s    V_4
+    IL_00e5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00ea:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::allButFirst4Numbers@27
+    IL_00ef:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00f4:  stloc.s    V_7
+    IL_00f6:  ldloc.s    V_7
+    IL_00f8:  ldloc.s    V_7
+    IL_00fa:  ldloc.s    V_7
+    IL_00fc:  ldloc.s    V_7
+    IL_00fe:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_0103:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0108:  ldloc.s    V_7
+    IL_010a:  newobj     instance void assembly/'Pipe #4 input at line 35@36'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_010f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0114:  ldsfld     class assembly/'Pipe #4 input at line 35@38-2' assembly/'Pipe #4 input at line 35@38-2'::@_instance
+    IL_0119:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_011e:  ldsfld     class assembly/'Pipe #4 input at line 35@39-3' assembly/'Pipe #4 input at line 35@39-3'::@_instance
+    IL_0123:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0128:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_012d:  stloc.s    V_6
+    IL_012f:  ldc.i4.2
+    IL_0130:  ldloc.s    V_6
+    IL_0132:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Skip<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(int32,
+                                                                                                                                                                                                                                                     class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0137:  stloc.s    V_8
+    IL_0139:  ldloc.s    V_8
+    IL_013b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0140:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> assembly::WAOrders2@34
+    IL_0145:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_014a:  stloc.s    V_10
+    IL_014c:  ldloc.s    V_10
+    IL_014e:  ldnull
+    IL_014f:  ldc.i4.0
+    IL_0150:  ldc.i4.0
+    IL_0151:  newobj     instance void assembly/'Pipe #5 input at line 44@45'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_0156:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_015b:  ldsfld     class assembly/'Pipe #5 input at line 44@46-1' assembly/'Pipe #5 input at line 44@46-1'::@_instance
+    IL_0160:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::TakeWhile<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0165:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_016a:  stloc.s    V_9
+    IL_016c:  ldloc.s    V_9
+    IL_016e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0173:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::firstNumbersLessThan6@43
+    IL_0178:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_017d:  stloc.s    V_12
+    IL_017f:  ldloc.s    V_12
+    IL_0181:  ldnull
+    IL_0182:  ldc.i4.0
+    IL_0183:  ldc.i4.0
+    IL_0184:  newobj     instance void assembly/'Pipe #6 input at line 51@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_0189:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_018e:  ldsfld     class assembly/'Pipe #6 input at line 51@53-1' assembly/'Pipe #6 input at line 51@53-1'::@_instance
+    IL_0193:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::SkipWhile<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0198:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_019d:  stloc.s    V_11
+    IL_019f:  ldloc.s    V_11
+    IL_01a1:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01a6:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::allButFirst3Numbers@50
+    IL_01ab:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          first3Numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_first3Numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[]
+          WAOrders()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::get_WAOrders()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          allButFirst4Numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_allButFirst4Numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>
+          WAOrders2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> assembly::get_WAOrders2()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          firstNumbersLessThan6()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_firstNumbersLessThan6()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          allButFirst3Numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_allButFirst3Numbers()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOff.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOff.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOff.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOff.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOff.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOff.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOn.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOn.il.net472.debug.bsl
new file mode 100644
index 00000000000..0b529d2bb16
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOn.il.net472.debug.bsl
@@ -0,0 +1,1414 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern System.Core
+{
+  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         
+  .ver 4:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname iAfterE@12
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/iAfterE@12::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/iAfterE@12::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/iAfterE@12::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/iAfterE@12::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/iAfterE@12::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/iAfterE@12::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/iAfterE@12::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/iAfterE@12::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/iAfterE@12::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/iAfterE@12::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/iAfterE@12::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/iAfterE@12::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/iAfterE@12::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/iAfterE@12::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/iAfterE@12::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/iAfterE@12::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/iAfterE@12::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                int32,
+                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'iAfterE@13-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,bool>
+  {
+    .field static assembly initonly class assembly/'iAfterE@13-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldstr      "ei"
+      IL_0006:  callvirt   instance bool [runtime]System.String::Contains(string)
+      IL_000b:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'iAfterE@13-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'iAfterE@13-1' assembly/'iAfterE@13-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@21'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 20@21'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 20@21'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@22-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 20@22-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 20@22-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 20@22-1' assembly/'Pipe #1 input at line 20@22-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@22-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 20@22-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 20@22-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 20@22-2' assembly/'Pipe #1 input at line 20@22-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@22-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 20@22-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 20@22-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class abstract auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 20@23-5'
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method assembly static bool  Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@23-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 20@23-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldnull
+      IL_0002:  ldftn      bool assembly/'Pipe #1 input at line 20@23-5'::Invoke(class [Utils]Utils/Product)
+      IL_0008:  newobj     instance void class [runtime]System.Func`2<class [Utils]Utils/Product,bool>::.ctor(object,
+                                                                                                               native int)
+      IL_000d:  call       bool [System.Core]System.Linq.Enumerable::Any<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                     class [runtime]System.Func`2<!!0,bool>)
+      IL_0012:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 20@23-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 20@23-4' assembly/'Pipe #1 input at line 20@23-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@24-6'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 20@24-6' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  newobj     instance void class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                     !1)
+      IL_000c:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 20@24-6'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 20@24-6' assembly/'Pipe #1 input at line 20@24-6'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname onlyOdd@32
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/onlyOdd@32::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/onlyOdd@32::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/onlyOdd@32::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/onlyOdd@32::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/onlyOdd@32::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/onlyOdd@32::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/onlyOdd@32::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/onlyOdd@32::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/onlyOdd@32::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/onlyOdd@32::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/onlyOdd@32::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/onlyOdd@32::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                int32,
+                                                                                int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'onlyOdd@33-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'onlyOdd@33-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.2
+      IL_0002:  rem
+      IL_0003:  ldc.i4.1
+      IL_0004:  ceq
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'onlyOdd@33-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'onlyOdd@33-1' assembly/'onlyOdd@33-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@39'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@39'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@39'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@40-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@40-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@40-1' assembly/'Pipe #2 input at line 38@40-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@40-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@40-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@40-2' assembly/'Pipe #2 input at line 38@40-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@40-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@40-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class abstract auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #2 input at line 38@41-5'
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method assembly static bool  Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0006:  ldc.i4.0
+      IL_0007:  cgt
+      IL_0009:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@41-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@41-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldnull
+      IL_0002:  ldftn      bool assembly/'Pipe #2 input at line 38@41-5'::Invoke(class [Utils]Utils/Product)
+      IL_0008:  newobj     instance void class [runtime]System.Func`2<class [Utils]Utils/Product,bool>::.ctor(object,
+                                                                                                               native int)
+      IL_000d:  call       bool [System.Core]System.Linq.Enumerable::All<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                     class [runtime]System.Func`2<!!0,bool>)
+      IL_0012:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@41-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@41-4' assembly/'Pipe #2 input at line 38@41-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@42-6'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@42-6' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  newobj     instance void class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                     !1)
+      IL_000c:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@42-6'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@42-6' assembly/'Pipe #2 input at line 38@42-6'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly bool iAfterE@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] productGroups@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@28
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly bool onlyOdd@30
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] productGroups2@37
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static bool get_iAfterE() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     bool assembly::iAfterE@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@17
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] get_productGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::productGroups@19
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@28
+    IL_0005:  ret
+  } 
+
+  .method public specialname static bool get_onlyOdd() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     bool assembly::onlyOdd@30
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] get_productGroups2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::productGroups2@37
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  10
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3)
+    IL_0000:  ldstr      "believe"
+    IL_0005:  ldstr      "relief"
+    IL_000a:  ldstr      "receipt"
+    IL_000f:  ldstr      "field"
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@8
+    IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0037:  ldnull
+    IL_0038:  ldc.i4.0
+    IL_0039:  ldnull
+    IL_003a:  newobj     instance void assembly/iAfterE@12::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                              int32,
+                                                                              string)
+    IL_003f:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0044:  ldsfld     class assembly/'iAfterE@13-1' assembly/'iAfterE@13-1'::@_instance
+    IL_0049:  callvirt   instance bool [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Exists<string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_004e:  stsfld     bool assembly::iAfterE@10
+    IL_0053:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0058:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@17
+    IL_005d:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0062:  stloc.1
+    IL_0063:  ldloc.1
+    IL_0064:  ldloc.1
+    IL_0065:  ldloc.1
+    IL_0066:  ldloc.1
+    IL_0067:  ldloc.1
+    IL_0068:  ldloc.1
+    IL_0069:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_006e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0073:  ldloc.1
+    IL_0074:  newobj     instance void assembly/'Pipe #1 input at line 20@21'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0079:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_007e:  ldsfld     class assembly/'Pipe #1 input at line 20@22-1' assembly/'Pipe #1 input at line 20@22-1'::@_instance
+    IL_0083:  ldsfld     class assembly/'Pipe #1 input at line 20@22-2' assembly/'Pipe #1 input at line 20@22-2'::@_instance
+    IL_0088:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_008d:  ldloc.1
+    IL_008e:  newobj     instance void assembly/'Pipe #1 input at line 20@22-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0093:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0098:  ldsfld     class assembly/'Pipe #1 input at line 20@23-4' assembly/'Pipe #1 input at line 20@23-4'::@_instance
+    IL_009d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00a2:  ldsfld     class assembly/'Pipe #1 input at line 20@24-6' assembly/'Pipe #1 input at line 20@24-6'::@_instance
+    IL_00a7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00ac:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00b1:  stloc.0
+    IL_00b2:  ldloc.0
+    IL_00b3:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00b8:  stsfld     class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::productGroups@19
+    IL_00bd:  ldc.i4.1
+    IL_00be:  ldc.i4.s   11
+    IL_00c0:  ldc.i4.3
+    IL_00c1:  ldc.i4.s   19
+    IL_00c3:  ldc.i4.s   41
+    IL_00c5:  ldc.i4.s   65
+    IL_00c7:  ldc.i4.s   19
+    IL_00c9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_00ce:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00d3:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00d8:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00dd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00e2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00e7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00ec:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00f1:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@28
+    IL_00f6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00fb:  ldnull
+    IL_00fc:  ldc.i4.0
+    IL_00fd:  ldc.i4.0
+    IL_00fe:  newobj     instance void assembly/onlyOdd@32::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                              int32,
+                                                                              int32)
+    IL_0103:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0108:  ldsfld     class assembly/'onlyOdd@33-1' assembly/'onlyOdd@33-1'::@_instance
+    IL_010d:  callvirt   instance bool [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::All<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0112:  stsfld     bool assembly::onlyOdd@30
+    IL_0117:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_011c:  stloc.3
+    IL_011d:  ldloc.3
+    IL_011e:  ldloc.3
+    IL_011f:  ldloc.3
+    IL_0120:  ldloc.3
+    IL_0121:  ldloc.3
+    IL_0122:  ldloc.3
+    IL_0123:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_0128:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_012d:  ldloc.3
+    IL_012e:  newobj     instance void assembly/'Pipe #2 input at line 38@39'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0133:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0138:  ldsfld     class assembly/'Pipe #2 input at line 38@40-1' assembly/'Pipe #2 input at line 38@40-1'::@_instance
+    IL_013d:  ldsfld     class assembly/'Pipe #2 input at line 38@40-2' assembly/'Pipe #2 input at line 38@40-2'::@_instance
+    IL_0142:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_0147:  ldloc.3
+    IL_0148:  newobj     instance void assembly/'Pipe #2 input at line 38@40-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_014d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0152:  ldsfld     class assembly/'Pipe #2 input at line 38@41-4' assembly/'Pipe #2 input at line 38@41-4'::@_instance
+    IL_0157:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_015c:  ldsfld     class assembly/'Pipe #2 input at line 38@42-6' assembly/'Pipe #2 input at line 38@42-6'::@_instance
+    IL_0161:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0166:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_016b:  stloc.2
+    IL_016c:  ldloc.2
+    IL_016d:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0172:  stsfld     class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::productGroups2@37
+    IL_0177:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property bool iAfterE()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get bool assembly::get_iAfterE()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[]
+          productGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::get_productGroups()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property bool onlyOdd()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get bool assembly::get_onlyOdd()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[]
+          productGroups2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::get_productGroups2()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOn.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOn.il.net472.release.bsl
new file mode 100644
index 00000000000..0b529d2bb16
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOn.il.net472.release.bsl
@@ -0,0 +1,1414 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern System.Core
+{
+  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         
+  .ver 4:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname iAfterE@12
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/iAfterE@12::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/iAfterE@12::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/iAfterE@12::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/iAfterE@12::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/iAfterE@12::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/iAfterE@12::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/iAfterE@12::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/iAfterE@12::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/iAfterE@12::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/iAfterE@12::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/iAfterE@12::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/iAfterE@12::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/iAfterE@12::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/iAfterE@12::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/iAfterE@12::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/iAfterE@12::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/iAfterE@12::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                int32,
+                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'iAfterE@13-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,bool>
+  {
+    .field static assembly initonly class assembly/'iAfterE@13-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldstr      "ei"
+      IL_0006:  callvirt   instance bool [runtime]System.String::Contains(string)
+      IL_000b:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'iAfterE@13-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'iAfterE@13-1' assembly/'iAfterE@13-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@21'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 20@21'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 20@21'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@22-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 20@22-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 20@22-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 20@22-1' assembly/'Pipe #1 input at line 20@22-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@22-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 20@22-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 20@22-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 20@22-2' assembly/'Pipe #1 input at line 20@22-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@22-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 20@22-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 20@22-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class abstract auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 20@23-5'
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method assembly static bool  Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@23-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 20@23-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldnull
+      IL_0002:  ldftn      bool assembly/'Pipe #1 input at line 20@23-5'::Invoke(class [Utils]Utils/Product)
+      IL_0008:  newobj     instance void class [runtime]System.Func`2<class [Utils]Utils/Product,bool>::.ctor(object,
+                                                                                                               native int)
+      IL_000d:  call       bool [System.Core]System.Linq.Enumerable::Any<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                     class [runtime]System.Func`2<!!0,bool>)
+      IL_0012:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 20@23-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 20@23-4' assembly/'Pipe #1 input at line 20@23-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@24-6'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 20@24-6' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  newobj     instance void class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                     !1)
+      IL_000c:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 20@24-6'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 20@24-6' assembly/'Pipe #1 input at line 20@24-6'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname onlyOdd@32
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/onlyOdd@32::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/onlyOdd@32::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/onlyOdd@32::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/onlyOdd@32::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/onlyOdd@32::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/onlyOdd@32::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/onlyOdd@32::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/onlyOdd@32::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/onlyOdd@32::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/onlyOdd@32::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/onlyOdd@32::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/onlyOdd@32::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                int32,
+                                                                                int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'onlyOdd@33-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'onlyOdd@33-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.2
+      IL_0002:  rem
+      IL_0003:  ldc.i4.1
+      IL_0004:  ceq
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'onlyOdd@33-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'onlyOdd@33-1' assembly/'onlyOdd@33-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@39'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@39'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@39'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@40-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@40-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@40-1' assembly/'Pipe #2 input at line 38@40-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@40-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@40-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@40-2' assembly/'Pipe #2 input at line 38@40-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@40-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@40-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class abstract auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #2 input at line 38@41-5'
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method assembly static bool  Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0006:  ldc.i4.0
+      IL_0007:  cgt
+      IL_0009:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@41-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@41-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldnull
+      IL_0002:  ldftn      bool assembly/'Pipe #2 input at line 38@41-5'::Invoke(class [Utils]Utils/Product)
+      IL_0008:  newobj     instance void class [runtime]System.Func`2<class [Utils]Utils/Product,bool>::.ctor(object,
+                                                                                                               native int)
+      IL_000d:  call       bool [System.Core]System.Linq.Enumerable::All<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                     class [runtime]System.Func`2<!!0,bool>)
+      IL_0012:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@41-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@41-4' assembly/'Pipe #2 input at line 38@41-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@42-6'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@42-6' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>> Invoke(class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  newobj     instance void class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                     !1)
+      IL_000c:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@42-6'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@42-6' assembly/'Pipe #2 input at line 38@42-6'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly bool iAfterE@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] productGroups@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@28
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly bool onlyOdd@30
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] productGroups2@37
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static bool get_iAfterE() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     bool assembly::iAfterE@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@17
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] get_productGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::productGroups@19
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@28
+    IL_0005:  ret
+  } 
+
+  .method public specialname static bool get_onlyOdd() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     bool assembly::onlyOdd@30
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] get_productGroups2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::productGroups2@37
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  10
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3)
+    IL_0000:  ldstr      "believe"
+    IL_0005:  ldstr      "relief"
+    IL_000a:  ldstr      "receipt"
+    IL_000f:  ldstr      "field"
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@8
+    IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0037:  ldnull
+    IL_0038:  ldc.i4.0
+    IL_0039:  ldnull
+    IL_003a:  newobj     instance void assembly/iAfterE@12::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                              int32,
+                                                                              string)
+    IL_003f:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0044:  ldsfld     class assembly/'iAfterE@13-1' assembly/'iAfterE@13-1'::@_instance
+    IL_0049:  callvirt   instance bool [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Exists<string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_004e:  stsfld     bool assembly::iAfterE@10
+    IL_0053:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0058:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@17
+    IL_005d:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0062:  stloc.1
+    IL_0063:  ldloc.1
+    IL_0064:  ldloc.1
+    IL_0065:  ldloc.1
+    IL_0066:  ldloc.1
+    IL_0067:  ldloc.1
+    IL_0068:  ldloc.1
+    IL_0069:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_006e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0073:  ldloc.1
+    IL_0074:  newobj     instance void assembly/'Pipe #1 input at line 20@21'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0079:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_007e:  ldsfld     class assembly/'Pipe #1 input at line 20@22-1' assembly/'Pipe #1 input at line 20@22-1'::@_instance
+    IL_0083:  ldsfld     class assembly/'Pipe #1 input at line 20@22-2' assembly/'Pipe #1 input at line 20@22-2'::@_instance
+    IL_0088:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_008d:  ldloc.1
+    IL_008e:  newobj     instance void assembly/'Pipe #1 input at line 20@22-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0093:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0098:  ldsfld     class assembly/'Pipe #1 input at line 20@23-4' assembly/'Pipe #1 input at line 20@23-4'::@_instance
+    IL_009d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00a2:  ldsfld     class assembly/'Pipe #1 input at line 20@24-6' assembly/'Pipe #1 input at line 20@24-6'::@_instance
+    IL_00a7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00ac:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00b1:  stloc.0
+    IL_00b2:  ldloc.0
+    IL_00b3:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00b8:  stsfld     class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::productGroups@19
+    IL_00bd:  ldc.i4.1
+    IL_00be:  ldc.i4.s   11
+    IL_00c0:  ldc.i4.3
+    IL_00c1:  ldc.i4.s   19
+    IL_00c3:  ldc.i4.s   41
+    IL_00c5:  ldc.i4.s   65
+    IL_00c7:  ldc.i4.s   19
+    IL_00c9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_00ce:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00d3:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00d8:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00dd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00e2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00e7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00ec:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00f1:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@28
+    IL_00f6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00fb:  ldnull
+    IL_00fc:  ldc.i4.0
+    IL_00fd:  ldc.i4.0
+    IL_00fe:  newobj     instance void assembly/onlyOdd@32::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                              int32,
+                                                                              int32)
+    IL_0103:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0108:  ldsfld     class assembly/'onlyOdd@33-1' assembly/'onlyOdd@33-1'::@_instance
+    IL_010d:  callvirt   instance bool [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::All<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0112:  stsfld     bool assembly::onlyOdd@30
+    IL_0117:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_011c:  stloc.3
+    IL_011d:  ldloc.3
+    IL_011e:  ldloc.3
+    IL_011f:  ldloc.3
+    IL_0120:  ldloc.3
+    IL_0121:  ldloc.3
+    IL_0122:  ldloc.3
+    IL_0123:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_0128:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_012d:  ldloc.3
+    IL_012e:  newobj     instance void assembly/'Pipe #2 input at line 38@39'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0133:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0138:  ldsfld     class assembly/'Pipe #2 input at line 38@40-1' assembly/'Pipe #2 input at line 38@40-1'::@_instance
+    IL_013d:  ldsfld     class assembly/'Pipe #2 input at line 38@40-2' assembly/'Pipe #2 input at line 38@40-2'::@_instance
+    IL_0142:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Core]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_0147:  ldloc.3
+    IL_0148:  newobj     instance void assembly/'Pipe #2 input at line 38@40-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_014d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0152:  ldsfld     class assembly/'Pipe #2 input at line 38@41-4' assembly/'Pipe #2 input at line 38@41-4'::@_instance
+    IL_0157:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_015c:  ldsfld     class assembly/'Pipe #2 input at line 38@42-6' assembly/'Pipe #2 input at line 38@42-6'::@_instance
+    IL_0161:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0166:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_016b:  stloc.2
+    IL_016c:  ldloc.2
+    IL_016d:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0172:  stsfld     class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::productGroups2@37
+    IL_0177:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property bool iAfterE()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get bool assembly::get_iAfterE()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[]
+          productGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::get_productGroups()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property bool onlyOdd()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get bool assembly::get_onlyOdd()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[]
+          productGroups2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [System.Core]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::get_productGroups2()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOn.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
new file mode 100644
index 00000000000..0762597cbf5
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
@@ -0,0 +1,1414 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern System.Linq
+{
+  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         
+  .ver 8:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname iAfterE@12
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/iAfterE@12::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/iAfterE@12::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/iAfterE@12::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/iAfterE@12::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/iAfterE@12::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/iAfterE@12::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/iAfterE@12::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/iAfterE@12::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/iAfterE@12::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/iAfterE@12::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/iAfterE@12::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/iAfterE@12::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/iAfterE@12::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/iAfterE@12::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/iAfterE@12::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/iAfterE@12::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/iAfterE@12::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                int32,
+                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'iAfterE@13-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,bool>
+  {
+    .field static assembly initonly class assembly/'iAfterE@13-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldstr      "ei"
+      IL_0006:  callvirt   instance bool [runtime]System.String::Contains(string)
+      IL_000b:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'iAfterE@13-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'iAfterE@13-1' assembly/'iAfterE@13-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@21'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 20@21'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 20@21'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@22-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 20@22-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 20@22-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 20@22-1' assembly/'Pipe #1 input at line 20@22-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@22-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 20@22-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 20@22-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 20@22-2' assembly/'Pipe #1 input at line 20@22-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@22-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 20@22-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 20@22-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class abstract auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 20@23-5'
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method assembly static bool  Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@23-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 20@23-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldnull
+      IL_0002:  ldftn      bool assembly/'Pipe #1 input at line 20@23-5'::Invoke(class [Utils]Utils/Product)
+      IL_0008:  newobj     instance void class [runtime]System.Func`2<class [Utils]Utils/Product,bool>::.ctor(object,
+                                                                                                                     native int)
+      IL_000d:  call       bool [System.Linq]System.Linq.Enumerable::Any<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                     class [runtime]System.Func`2<!!0,bool>)
+      IL_0012:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 20@23-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 20@23-4' assembly/'Pipe #1 input at line 20@23-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@24-6'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 20@24-6' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  newobj     instance void class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                           !1)
+      IL_000c:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 20@24-6'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 20@24-6' assembly/'Pipe #1 input at line 20@24-6'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname onlyOdd@32
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/onlyOdd@32::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/onlyOdd@32::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/onlyOdd@32::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/onlyOdd@32::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/onlyOdd@32::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/onlyOdd@32::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/onlyOdd@32::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/onlyOdd@32::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/onlyOdd@32::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/onlyOdd@32::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/onlyOdd@32::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/onlyOdd@32::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                int32,
+                                                                                int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'onlyOdd@33-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'onlyOdd@33-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.2
+      IL_0002:  rem
+      IL_0003:  ldc.i4.1
+      IL_0004:  ceq
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'onlyOdd@33-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'onlyOdd@33-1' assembly/'onlyOdd@33-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@39'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@39'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@39'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@40-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@40-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@40-1' assembly/'Pipe #2 input at line 38@40-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@40-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@40-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@40-2' assembly/'Pipe #2 input at line 38@40-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@40-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@40-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class abstract auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #2 input at line 38@41-5'
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method assembly static bool  Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0006:  ldc.i4.0
+      IL_0007:  cgt
+      IL_0009:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@41-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@41-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldnull
+      IL_0002:  ldftn      bool assembly/'Pipe #2 input at line 38@41-5'::Invoke(class [Utils]Utils/Product)
+      IL_0008:  newobj     instance void class [runtime]System.Func`2<class [Utils]Utils/Product,bool>::.ctor(object,
+                                                                                                                     native int)
+      IL_000d:  call       bool [System.Linq]System.Linq.Enumerable::All<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                     class [runtime]System.Func`2<!!0,bool>)
+      IL_0012:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@41-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@41-4' assembly/'Pipe #2 input at line 38@41-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@42-6'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@42-6' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  newobj     instance void class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                           !1)
+      IL_000c:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@42-6'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@42-6' assembly/'Pipe #2 input at line 38@42-6'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly bool iAfterE@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] productGroups@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@28
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly bool onlyOdd@30
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] productGroups2@37
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static bool get_iAfterE() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     bool assembly::iAfterE@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@17
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] get_productGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::productGroups@19
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@28
+    IL_0005:  ret
+  } 
+
+  .method public specialname static bool get_onlyOdd() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     bool assembly::onlyOdd@30
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] get_productGroups2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::productGroups2@37
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  10
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3)
+    IL_0000:  ldstr      "believe"
+    IL_0005:  ldstr      "relief"
+    IL_000a:  ldstr      "receipt"
+    IL_000f:  ldstr      "field"
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@8
+    IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0037:  ldnull
+    IL_0038:  ldc.i4.0
+    IL_0039:  ldnull
+    IL_003a:  newobj     instance void assembly/iAfterE@12::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                              int32,
+                                                                              string)
+    IL_003f:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0044:  ldsfld     class assembly/'iAfterE@13-1' assembly/'iAfterE@13-1'::@_instance
+    IL_0049:  callvirt   instance bool [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Exists<string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_004e:  stsfld     bool assembly::iAfterE@10
+    IL_0053:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0058:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@17
+    IL_005d:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0062:  stloc.1
+    IL_0063:  ldloc.1
+    IL_0064:  ldloc.1
+    IL_0065:  ldloc.1
+    IL_0066:  ldloc.1
+    IL_0067:  ldloc.1
+    IL_0068:  ldloc.1
+    IL_0069:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_006e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0073:  ldloc.1
+    IL_0074:  newobj     instance void assembly/'Pipe #1 input at line 20@21'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0079:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_007e:  ldsfld     class assembly/'Pipe #1 input at line 20@22-1' assembly/'Pipe #1 input at line 20@22-1'::@_instance
+    IL_0083:  ldsfld     class assembly/'Pipe #1 input at line 20@22-2' assembly/'Pipe #1 input at line 20@22-2'::@_instance
+    IL_0088:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_008d:  ldloc.1
+    IL_008e:  newobj     instance void assembly/'Pipe #1 input at line 20@22-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0093:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0098:  ldsfld     class assembly/'Pipe #1 input at line 20@23-4' assembly/'Pipe #1 input at line 20@23-4'::@_instance
+    IL_009d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00a2:  ldsfld     class assembly/'Pipe #1 input at line 20@24-6' assembly/'Pipe #1 input at line 20@24-6'::@_instance
+    IL_00a7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00ac:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00b1:  stloc.0
+    IL_00b2:  ldloc.0
+    IL_00b3:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00b8:  stsfld     class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::productGroups@19
+    IL_00bd:  ldc.i4.1
+    IL_00be:  ldc.i4.s   11
+    IL_00c0:  ldc.i4.3
+    IL_00c1:  ldc.i4.s   19
+    IL_00c3:  ldc.i4.s   41
+    IL_00c5:  ldc.i4.s   65
+    IL_00c7:  ldc.i4.s   19
+    IL_00c9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_00ce:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00d3:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00d8:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00dd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00e2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00e7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00ec:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00f1:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@28
+    IL_00f6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00fb:  ldnull
+    IL_00fc:  ldc.i4.0
+    IL_00fd:  ldc.i4.0
+    IL_00fe:  newobj     instance void assembly/onlyOdd@32::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                              int32,
+                                                                              int32)
+    IL_0103:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0108:  ldsfld     class assembly/'onlyOdd@33-1' assembly/'onlyOdd@33-1'::@_instance
+    IL_010d:  callvirt   instance bool [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::All<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0112:  stsfld     bool assembly::onlyOdd@30
+    IL_0117:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_011c:  stloc.3
+    IL_011d:  ldloc.3
+    IL_011e:  ldloc.3
+    IL_011f:  ldloc.3
+    IL_0120:  ldloc.3
+    IL_0121:  ldloc.3
+    IL_0122:  ldloc.3
+    IL_0123:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_0128:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_012d:  ldloc.3
+    IL_012e:  newobj     instance void assembly/'Pipe #2 input at line 38@39'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0133:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0138:  ldsfld     class assembly/'Pipe #2 input at line 38@40-1' assembly/'Pipe #2 input at line 38@40-1'::@_instance
+    IL_013d:  ldsfld     class assembly/'Pipe #2 input at line 38@40-2' assembly/'Pipe #2 input at line 38@40-2'::@_instance
+    IL_0142:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_0147:  ldloc.3
+    IL_0148:  newobj     instance void assembly/'Pipe #2 input at line 38@40-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_014d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0152:  ldsfld     class assembly/'Pipe #2 input at line 38@41-4' assembly/'Pipe #2 input at line 38@41-4'::@_instance
+    IL_0157:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_015c:  ldsfld     class assembly/'Pipe #2 input at line 38@42-6' assembly/'Pipe #2 input at line 38@42-6'::@_instance
+    IL_0161:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0166:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_016b:  stloc.2
+    IL_016c:  ldloc.2
+    IL_016d:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0172:  stsfld     class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::productGroups2@37
+    IL_0177:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property bool iAfterE()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get bool assembly::get_iAfterE()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[]
+          productGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::get_productGroups()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property bool onlyOdd()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get bool assembly::get_onlyOdd()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[]
+          productGroups2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::get_productGroups2()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOn.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOn.il.netcore.release.bsl
new file mode 100644
index 00000000000..0762597cbf5
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Quantifiers01.fs.RealInternalSignatureOn.il.netcore.release.bsl
@@ -0,0 +1,1414 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern System.Linq
+{
+  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         
+  .ver 8:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname iAfterE@12
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/iAfterE@12::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/iAfterE@12::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (string V_0,
+               string V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/iAfterE@12::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/iAfterE@12::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/iAfterE@12::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      string assembly/iAfterE@12::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/iAfterE@12::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/iAfterE@12::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldnull
+      IL_008d:  stfld      string assembly/iAfterE@12::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/iAfterE@12::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/iAfterE@12::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/iAfterE@12::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/iAfterE@12::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/iAfterE@12::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/iAfterE@12::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/iAfterE@12::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/iAfterE@12::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/iAfterE@12::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                int32,
+                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'iAfterE@13-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,bool>
+  {
+    .field static assembly initonly class assembly/'iAfterE@13-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(string w) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldstr      "ei"
+      IL_0006:  callvirt   instance bool [runtime]System.String::Contains(string)
+      IL_000b:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'iAfterE@13-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'iAfterE@13-1' assembly/'iAfterE@13-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@21'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 20@21'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 20@21'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@22-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 20@22-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 20@22-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 20@22-1' assembly/'Pipe #1 input at line 20@22-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@22-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 20@22-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 20@22-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 20@22-2' assembly/'Pipe #1 input at line 20@22-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@22-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 20@22-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 20@22-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class abstract auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 20@23-5'
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method assembly static bool  Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@23-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 20@23-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldnull
+      IL_0002:  ldftn      bool assembly/'Pipe #1 input at line 20@23-5'::Invoke(class [Utils]Utils/Product)
+      IL_0008:  newobj     instance void class [runtime]System.Func`2<class [Utils]Utils/Product,bool>::.ctor(object,
+                                                                                                                     native int)
+      IL_000d:  call       bool [System.Linq]System.Linq.Enumerable::Any<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                     class [runtime]System.Func`2<!!0,bool>)
+      IL_0012:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 20@23-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 20@23-4' assembly/'Pipe #1 input at line 20@23-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 20@24-6'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 20@24-6' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  newobj     instance void class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                           !1)
+      IL_000c:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 20@24-6'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 20@24-6' assembly/'Pipe #1 input at line 20@24-6'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname onlyOdd@32
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/onlyOdd@32::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/onlyOdd@32::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/onlyOdd@32::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/onlyOdd@32::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/onlyOdd@32::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/onlyOdd@32::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/onlyOdd@32::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/onlyOdd@32::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/onlyOdd@32::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/onlyOdd@32::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/onlyOdd@32::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/onlyOdd@32::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/onlyOdd@32::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/onlyOdd@32::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                int32,
+                                                                                int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'onlyOdd@33-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'onlyOdd@33-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.2
+      IL_0002:  rem
+      IL_0003:  ldc.i4.1
+      IL_0004:  ceq
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'onlyOdd@33-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'onlyOdd@33-1' assembly/'onlyOdd@33-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@39'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@39'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@39'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@40-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@40-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@40-1' assembly/'Pipe #2 input at line 38@40-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@40-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@40-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@40-2' assembly/'Pipe #2 input at line 38@40-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@40-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@40-3'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> _arg2) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 38@40-3'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class abstract auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #2 input at line 38@41-5'
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method assembly static bool  Invoke(class [Utils]Utils/Product x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0006:  ldc.i4.0
+      IL_0007:  cgt
+      IL_0009:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@41-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@41-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldnull
+      IL_0002:  ldftn      bool assembly/'Pipe #2 input at line 38@41-5'::Invoke(class [Utils]Utils/Product)
+      IL_0008:  newobj     instance void class [runtime]System.Func`2<class [Utils]Utils/Product,bool>::.ctor(object,
+                                                                                                                     native int)
+      IL_000d:  call       bool [System.Linq]System.Linq.Enumerable::All<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                                     class [runtime]System.Func`2<!!0,bool>)
+      IL_0012:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@41-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@41-4' assembly/'Pipe #2 input at line 38@41-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 38@42-6'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 38@42-6' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>> Invoke(class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product> g) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance !0 class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>::get_Key()
+      IL_0006:  ldarg.1
+      IL_0007:  newobj     instance void class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>::.ctor(!0,
+                                                                                                                                                                           !1)
+      IL_000c:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 38@42-6'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 38@42-6' assembly/'Pipe #2 input at line 38@42-6'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@8
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly bool iAfterE@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] productGroups@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@28
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly bool onlyOdd@30
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] productGroups2@37
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@8
+    IL_0005:  ret
+  } 
+
+  .method public specialname static bool get_iAfterE() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     bool assembly::iAfterE@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@17
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] get_productGroups() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::productGroups@19
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@28
+    IL_0005:  ret
+  } 
+
+  .method public specialname static bool get_onlyOdd() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     bool assembly::onlyOdd@30
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] get_productGroups2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::productGroups2@37
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  10
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3)
+    IL_0000:  ldstr      "believe"
+    IL_0005:  ldstr      "relief"
+    IL_000a:  ldstr      "receipt"
+    IL_000f:  ldstr      "field"
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@8
+    IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0037:  ldnull
+    IL_0038:  ldc.i4.0
+    IL_0039:  ldnull
+    IL_003a:  newobj     instance void assembly/iAfterE@12::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                              int32,
+                                                                              string)
+    IL_003f:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0044:  ldsfld     class assembly/'iAfterE@13-1' assembly/'iAfterE@13-1'::@_instance
+    IL_0049:  callvirt   instance bool [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Exists<string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_004e:  stsfld     bool assembly::iAfterE@10
+    IL_0053:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0058:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@17
+    IL_005d:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0062:  stloc.1
+    IL_0063:  ldloc.1
+    IL_0064:  ldloc.1
+    IL_0065:  ldloc.1
+    IL_0066:  ldloc.1
+    IL_0067:  ldloc.1
+    IL_0068:  ldloc.1
+    IL_0069:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_006e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0073:  ldloc.1
+    IL_0074:  newobj     instance void assembly/'Pipe #1 input at line 20@21'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0079:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_007e:  ldsfld     class assembly/'Pipe #1 input at line 20@22-1' assembly/'Pipe #1 input at line 20@22-1'::@_instance
+    IL_0083:  ldsfld     class assembly/'Pipe #1 input at line 20@22-2' assembly/'Pipe #1 input at line 20@22-2'::@_instance
+    IL_0088:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_008d:  ldloc.1
+    IL_008e:  newobj     instance void assembly/'Pipe #1 input at line 20@22-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0093:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0098:  ldsfld     class assembly/'Pipe #1 input at line 20@23-4' assembly/'Pipe #1 input at line 20@23-4'::@_instance
+    IL_009d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00a2:  ldsfld     class assembly/'Pipe #1 input at line 20@24-6' assembly/'Pipe #1 input at line 20@24-6'::@_instance
+    IL_00a7:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00ac:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00b1:  stloc.0
+    IL_00b2:  ldloc.0
+    IL_00b3:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00b8:  stsfld     class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::productGroups@19
+    IL_00bd:  ldc.i4.1
+    IL_00be:  ldc.i4.s   11
+    IL_00c0:  ldc.i4.3
+    IL_00c1:  ldc.i4.s   19
+    IL_00c3:  ldc.i4.s   41
+    IL_00c5:  ldc.i4.s   65
+    IL_00c7:  ldc.i4.s   19
+    IL_00c9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_00ce:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00d3:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00d8:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00dd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00e2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00e7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00ec:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00f1:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@28
+    IL_00f6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00fb:  ldnull
+    IL_00fc:  ldc.i4.0
+    IL_00fd:  ldc.i4.0
+    IL_00fe:  newobj     instance void assembly/onlyOdd@32::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                              int32,
+                                                                              int32)
+    IL_0103:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0108:  ldsfld     class assembly/'onlyOdd@33-1' assembly/'onlyOdd@33-1'::@_instance
+    IL_010d:  callvirt   instance bool [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::All<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0112:  stsfld     bool assembly::onlyOdd@30
+    IL_0117:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_011c:  stloc.3
+    IL_011d:  ldloc.3
+    IL_011e:  ldloc.3
+    IL_011f:  ldloc.3
+    IL_0120:  ldloc.3
+    IL_0121:  ldloc.3
+    IL_0122:  ldloc.3
+    IL_0123:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_0128:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_012d:  ldloc.3
+    IL_012e:  newobj     instance void assembly/'Pipe #2 input at line 38@39'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0133:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0138:  ldsfld     class assembly/'Pipe #2 input at line 38@40-1' assembly/'Pipe #2 input at line 38@40-1'::@_instance
+    IL_013d:  ldsfld     class assembly/'Pipe #2 input at line 38@40-2' assembly/'Pipe #2 input at line 38@40-2'::@_instance
+    IL_0142:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [System.Linq]System.Linq.IGrouping`2<!!1,!!2>,!!3> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::GroupValBy<class [Utils]Utils/Product,string,class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!3>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>,
+                                                                                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>)
+    IL_0147:  ldloc.3
+    IL_0148:  newobj     instance void assembly/'Pipe #2 input at line 38@40-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_014d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0152:  ldsfld     class assembly/'Pipe #2 input at line 38@41-4' assembly/'Pipe #2 input at line 38@41-4'::@_instance
+    IL_0157:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_015c:  ldsfld     class assembly/'Pipe #2 input at line 38@42-6' assembly/'Pipe #2 input at line 38@42-6'::@_instance
+    IL_0161:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0166:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_016b:  stloc.2
+    IL_016c:  ldloc.2
+    IL_016d:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0172:  stsfld     class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::productGroups2@37
+    IL_0177:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property bool iAfterE()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get bool assembly::get_iAfterE()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[]
+          productGroups()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::get_productGroups()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property bool onlyOdd()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get bool assembly::get_onlyOdd()
+  } 
+  .property class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[]
+          productGroups2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,class [System.Linq]System.Linq.IGrouping`2<string,class [Utils]Utils/Product>>[] assembly::get_productGroups2()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOff.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOff.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOff.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOff.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOff.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOff.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOn.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOn.il.net472.debug.bsl
new file mode 100644
index 00000000000..b51d44ce3a7
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOn.il.net472.debug.bsl
@@ -0,0 +1,3852 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 11@12-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 11@12-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<int32> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<int32>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 11@12-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 11@12-1' assembly/'Pipe #1 input at line 11@12-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 11@13'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0073
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0066
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0094
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'Pipe #1 input at line 11@12-1' assembly/'Pipe #1 input at line 11@12-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                   class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0046:  br.s       IL_0066
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  ldc.i4.1
+      IL_005e:  add
+      IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+      IL_0064:  ldc.i4.1
+      IL_0065:  ret
+
+      IL_0066:  ldarg.0
+      IL_0067:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_006c:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0071:  brtrue.s   IL_0048
+
+      IL_0073:  ldarg.0
+      IL_0074:  ldc.i4.3
+      IL_0075:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_007a:  ldarg.0
+      IL_007b:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_0080:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_0085:  nop
+      IL_0086:  ldarg.0
+      IL_0087:  ldnull
+      IL_0088:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_008d:  ldarg.0
+      IL_008e:  ldc.i4.3
+      IL_008f:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0094:  ldarg.0
+      IL_0095:  ldc.i4.0
+      IL_0096:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+      IL_009b:  ldc.i4.0
+      IL_009c:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 11@13'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                              int32,
+                                                                                              int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'productNames@21-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'productNames@21-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Product>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'productNames@21-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'productNames@21-1' assembly/'productNames@21-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname productNames@22
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/productNames@22::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/productNames@22::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productNames@22::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0076
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0069
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0097
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'productNames@21-1' assembly/'productNames@21-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                  class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/productNames@22::pc
+      IL_0046:  br.s       IL_0069
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/productNames@22::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0062:  stfld      string assembly/productNames@22::current
+      IL_0067:  ldc.i4.1
+      IL_0068:  ret
+
+      IL_0069:  ldarg.0
+      IL_006a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_006f:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0074:  brtrue.s   IL_0048
+
+      IL_0076:  ldarg.0
+      IL_0077:  ldc.i4.3
+      IL_0078:  stfld      int32 assembly/productNames@22::pc
+      IL_007d:  ldarg.0
+      IL_007e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_0083:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_0088:  nop
+      IL_0089:  ldarg.0
+      IL_008a:  ldnull
+      IL_008b:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_0090:  ldarg.0
+      IL_0091:  ldc.i4.3
+      IL_0092:  stfld      int32 assembly/productNames@22::pc
+      IL_0097:  ldarg.0
+      IL_0098:  ldnull
+      IL_0099:  stfld      string assembly/productNames@22::current
+      IL_009e:  ldc.i4.0
+      IL_009f:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productNames@22::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/productNames@22::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/productNames@22::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/productNames@22::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/productNames@22::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productNames@22::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/productNames@22::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/productNames@22::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                int32,
+                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 28@29-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 28@29-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<int32> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<int32>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 28@29-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 28@29-1' assembly/'Pipe #2 input at line 28@29-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #2 input at line 28@30'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #2 input at line 28@30'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_007b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_006e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_009c
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'Pipe #2 input at line 28@29-1' assembly/'Pipe #2 input at line 28@29-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                   class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0046:  br.s       IL_006e
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_005b:  ldarg.0
+      IL_005c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+      IL_0061:  ldloc.0
+      IL_0062:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Item(int32)
+      IL_0067:  stfld      string assembly/'Pipe #2 input at line 28@30'::current
+      IL_006c:  ldc.i4.1
+      IL_006d:  ret
+
+      IL_006e:  ldarg.0
+      IL_006f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_0074:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0079:  brtrue.s   IL_0048
+
+      IL_007b:  ldarg.0
+      IL_007c:  ldc.i4.3
+      IL_007d:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0082:  ldarg.0
+      IL_0083:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_0088:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_008d:  nop
+      IL_008e:  ldarg.0
+      IL_008f:  ldnull
+      IL_0090:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_0095:  ldarg.0
+      IL_0096:  ldc.i4.3
+      IL_0097:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_009c:  ldarg.0
+      IL_009d:  ldnull
+      IL_009e:  stfld      string assembly/'Pipe #2 input at line 28@30'::current
+      IL_00a3:  ldc.i4.0
+      IL_00a4:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #2 input at line 28@30'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #2 input at line 28@30'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #2 input at line 28@30'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                              int32,
+                                                                                              string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 37@38-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 37@38-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<string> Invoke(string _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (string V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<string>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 37@38-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 37@38-1' assembly/'Pipe #3 input at line 37@38-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #3 input at line 37@39'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<string,string>>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Tuple`2<string,string> current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 class [runtime]System.Tuple`2<string,string> current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<string,string>>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (string V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0027
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0084
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0077
+
+      IL_0021:  nop
+      IL_0022:  br         IL_00a5
+
+      IL_0027:  nop
+      IL_0028:  ldarg.0
+      IL_0029:  ldsfld     class assembly/'Pipe #3 input at line 37@38-1' assembly/'Pipe #3 input at line 37@38-1'::@_instance
+      IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_0033:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>,string>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                      class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0038:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_003d:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_0042:  ldarg.0
+      IL_0043:  ldc.i4.1
+      IL_0044:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_0049:  br.s       IL_0077
+
+      IL_004b:  ldarg.0
+      IL_004c:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_0051:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_0056:  stloc.0
+      IL_0057:  ldarg.0
+      IL_0058:  ldc.i4.2
+      IL_0059:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_005e:  ldarg.0
+      IL_005f:  ldloc.0
+      IL_0060:  callvirt   instance string [runtime]System.String::ToUpper()
+      IL_0065:  ldloc.0
+      IL_0066:  callvirt   instance string [runtime]System.String::ToLower()
+      IL_006b:  newobj     instance void class [runtime]System.Tuple`2<string,string>::.ctor(!0,
+                                                                                              !1)
+      IL_0070:  stfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+      IL_0075:  ldc.i4.1
+      IL_0076:  ret
+
+      IL_0077:  ldarg.0
+      IL_0078:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_007d:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0082:  brtrue.s   IL_004b
+
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_0091:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_0096:  nop
+      IL_0097:  ldarg.0
+      IL_0098:  ldnull
+      IL_0099:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_009e:  ldarg.0
+      IL_009f:  ldc.i4.3
+      IL_00a0:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_00a5:  ldarg.0
+      IL_00a6:  ldnull
+      IL_00a7:  stfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+      IL_00ac:  ldc.i4.0
+      IL_00ad:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,string> get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<string,string>> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #3 input at line 37@39'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                              int32,
+                                                                                              class [runtime]System.Tuple`2<string,string>)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 44@45-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 44@45-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<int32> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<int32>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 44@45-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 44@45-1' assembly/'Pipe #4 input at line 44@45-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #4 input at line 44@46'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<string,bool>>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Tuple`2<string,bool> current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 class [runtime]System.Tuple`2<string,bool> current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<string,bool>>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,bool>>& next) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0027
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0089
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_007c
+
+      IL_0021:  nop
+      IL_0022:  br         IL_00aa
+
+      IL_0027:  nop
+      IL_0028:  ldarg.0
+      IL_0029:  ldsfld     class assembly/'Pipe #4 input at line 44@45-1' assembly/'Pipe #4 input at line 44@45-1'::@_instance
+      IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_0033:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                   class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0038:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_003d:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0042:  ldarg.0
+      IL_0043:  ldc.i4.1
+      IL_0044:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0049:  br.s       IL_007c
+
+      IL_004b:  ldarg.0
+      IL_004c:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0051:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0056:  stloc.0
+      IL_0057:  ldarg.0
+      IL_0058:  ldc.i4.2
+      IL_0059:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_005e:  ldarg.0
+      IL_005f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+      IL_0064:  ldloc.0
+      IL_0065:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Item(int32)
+      IL_006a:  ldloc.0
+      IL_006b:  ldc.i4.2
+      IL_006c:  rem
+      IL_006d:  ldc.i4.0
+      IL_006e:  ceq
+      IL_0070:  newobj     instance void class [runtime]System.Tuple`2<string,bool>::.ctor(!0,
+                                                                                            !1)
+      IL_0075:  stfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+      IL_007a:  ldc.i4.1
+      IL_007b:  ret
+
+      IL_007c:  ldarg.0
+      IL_007d:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0082:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0087:  brtrue.s   IL_004b
+
+      IL_0089:  ldarg.0
+      IL_008a:  ldc.i4.3
+      IL_008b:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0090:  ldarg.0
+      IL_0091:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0096:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_009b:  nop
+      IL_009c:  ldarg.0
+      IL_009d:  ldnull
+      IL_009e:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_00a3:  ldarg.0
+      IL_00a4:  ldc.i4.3
+      IL_00a5:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_00aa:  ldarg.0
+      IL_00ab:  ldnull
+      IL_00ac:  stfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+      IL_00b1:  ldc.i4.0
+      IL_00b2:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,bool> get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<string,bool>> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #4 input at line 44@46'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                              int32,
+                                                                                              class [runtime]System.Tuple`2<string,bool>)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 51@52-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 51@52-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Product>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 51@52-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 51@52-1' assembly/'Pipe #5 input at line 51@52-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #5 input at line 51@53'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>>& next) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0027
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_008a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_007d
+
+      IL_0021:  nop
+      IL_0022:  br         IL_00ab
+
+      IL_0027:  nop
+      IL_0028:  ldarg.0
+      IL_0029:  ldsfld     class assembly/'Pipe #5 input at line 51@52-1' assembly/'Pipe #5 input at line 51@52-1'::@_instance
+      IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_0033:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                  class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0038:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_003d:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0042:  ldarg.0
+      IL_0043:  ldc.i4.1
+      IL_0044:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0049:  br.s       IL_007d
+
+      IL_004b:  ldarg.0
+      IL_004c:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0051:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_0056:  stloc.0
+      IL_0057:  ldarg.0
+      IL_0058:  ldc.i4.2
+      IL_0059:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_005e:  ldarg.0
+      IL_005f:  ldloc.0
+      IL_0060:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0065:  ldloc.0
+      IL_0066:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_006b:  ldloc.0
+      IL_006c:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0071:  newobj     instance void class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                 !1,
+                                                                                                                                 !2)
+      IL_0076:  stfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+      IL_007b:  ldc.i4.1
+      IL_007c:  ret
+
+      IL_007d:  ldarg.0
+      IL_007e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0083:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0088:  brtrue.s   IL_004b
+
+      IL_008a:  ldarg.0
+      IL_008b:  ldc.i4.3
+      IL_008c:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0091:  ldarg.0
+      IL_0092:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0097:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_009c:  nop
+      IL_009d:  ldarg.0
+      IL_009e:  ldnull
+      IL_009f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_00a4:  ldarg.0
+      IL_00a5:  ldc.i4.3
+      IL_00a6:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_00ab:  ldarg.0
+      IL_00ac:  ldnull
+      IL_00ad:  stfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+      IL_00b2:  ldc.i4.0
+      IL_00b3:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #5 input at line 51@53'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                              int32,
+                                                                                              class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@60'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 59@60'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 59@60'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<int32,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@61-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@61-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.5
+      IL_0002:  clt
+      IL_0004:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@61-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@61-1' assembly/'Pipe #6 input at line 59@61-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@62-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@62-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+      IL_0005:  ldarg.1
+      IL_0006:  tail.
+      IL_0008:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Item(int32)
+      IL_000d:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@62-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@62-2' assembly/'Pipe #6 input at line 59@62-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 71@73-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 a
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 int32 a) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@73-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      int32 assembly/'Pipe #7 input at line 71@73-1'::a
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,object> Invoke(int32 _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@73-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      int32 assembly/'Pipe #7 input at line 71@73-1'::a
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<int32,int32>::.ctor(!0,
+                                                                                            !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<int32,int32>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 71@72'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@72'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@72'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@72'::builder@
+      IL_000e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbersB()
+      IL_0013:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0018:  ldarg.0
+      IL_0019:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@72'::builder@
+      IL_001e:  ldloc.0
+      IL_001f:  newobj     instance void assembly/'Pipe #7 input at line 71@73-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                int32)
+      IL_0024:  tail.
+      IL_0026:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,int32>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 71@74-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<int32,int32>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 71@74-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<int32,int32>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<int32,int32> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<int32,int32>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<int32,int32>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  clt
+      IL_0012:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 71@74-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 71@74-2' assembly/'Pipe #7 input at line 71@74-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 71@75-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Tuple`2<int32,int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 71@75-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Tuple`2<int32,int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,int32> Invoke(class [runtime]System.Tuple`2<int32,int32> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<int32,int32>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<int32,int32>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  newobj     instance void class [runtime]System.Tuple`2<int32,int32>::.ctor(!0,
+                                                                                            !1)
+      IL_0015:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 71@75-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 71@75-3' assembly/'Pipe #7 input at line 71@75-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #8 input at line 81@83-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@83-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'Pipe #8 input at line 81@83-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@83-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'Pipe #8 input at line 81@83-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                     !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #8 input at line 81@82'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@82'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@82'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@82'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@82'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'Pipe #8 input at line 81@83-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #8 input at line 81@84-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #8 input at line 81@84-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Order::get_Total()
+      IL_0014:  ldc.i4     0xc350
+      IL_0019:  ldc.i4.0
+      IL_001a:  ldc.i4.0
+      IL_001b:  ldc.i4.0
+      IL_001c:  ldc.i4.2
+      IL_001d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                            int32,
+                                                                            int32,
+                                                                            bool,
+                                                                            uint8)
+      IL_0022:  call       bool [netstandard]System.Decimal::op_LessThan(valuetype [netstandard]System.Decimal,
+                                                                         valuetype [netstandard]System.Decimal)
+      IL_0027:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #8 input at line 81@84-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #8 input at line 81@84-2' assembly/'Pipe #8 input at line 81@84-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #8 input at line 81@85-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'Pipe #8 input at line 81@85-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Order::get_Total()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                !1,
+                                                                                                                                !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #8 input at line 81@85-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #8 input at line 81@85-3' assembly/'Pipe #8 input at line 81@85-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #9 input at line 90@92-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@92-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'Pipe #9 input at line 90@92-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@92-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'Pipe #9 input at line 90@92-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                     !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #9 input at line 90@91'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@91'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@91'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@91'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@91'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'Pipe #9 input at line 90@92-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #9 input at line 90@93-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #9 input at line 90@93-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1,
+               valuetype [runtime]System.DateTime V_2,
+               valuetype [runtime]System.DateTime V_3,
+               valuetype [runtime]System.DateTime V_4,
+               valuetype [runtime]System.DateTime V_5,
+               valuetype [runtime]System.DateTime V_6,
+               valuetype [runtime]System.DateTime V_7)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0014:  stloc.2
+      IL_0015:  ldc.i4     0x7ce
+      IL_001a:  ldc.i4.1
+      IL_001b:  ldc.i4.1
+      IL_001c:  newobj     instance void [runtime]System.DateTime::.ctor(int32,
+                                                                          int32,
+                                                                          int32)
+      IL_0021:  stloc.3
+      IL_0022:  ldloc.2
+      IL_0023:  stloc.s    V_4
+      IL_0025:  ldloc.3
+      IL_0026:  stloc.s    V_5
+      IL_0028:  ldloc.s    V_4
+      IL_002a:  stloc.s    V_6
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  stloc.s    V_7
+      IL_0030:  ldloc.s    V_6
+      IL_0032:  ldloc.s    V_7
+      IL_0034:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_0039:  ldc.i4.0
+      IL_003a:  clt
+      IL_003c:  ldc.i4.0
+      IL_003d:  ceq
+      IL_003f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #9 input at line 90@93-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #9 input at line 90@93-2' assembly/'Pipe #9 input at line 90@93-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #9 input at line 90@94-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>
+  {
+    .field static assembly initonly class assembly/'Pipe #9 input at line 90@94-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>::.ctor(!0,
+                                                                                                                                 !1,
+                                                                                                                                 !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #9 input at line 90@94-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #9 input at line 90@94-3' assembly/'Pipe #9 input at line 90@94-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders3@101-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders3@101-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'orders3@101-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders3@101-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'orders3@101-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                     !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit orders3@100
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders3@100::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders3@100::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders3@100::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders3@100::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'orders3@101-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders3@102-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'orders3@102-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Order::get_Total()
+      IL_0014:  ldc.i4     0x4e20
+      IL_0019:  ldc.i4.0
+      IL_001a:  ldc.i4.0
+      IL_001b:  ldc.i4.0
+      IL_001c:  ldc.i4.1
+      IL_001d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                            int32,
+                                                                            int32,
+                                                                            bool,
+                                                                            uint8)
+      IL_0022:  call       bool [netstandard]System.Decimal::op_GreaterThanOrEqual(valuetype [netstandard]System.Decimal,
+                                                                                   valuetype [netstandard]System.Decimal)
+      IL_0027:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders3@102-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders3@102-2' assembly/'orders3@102-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders3@103-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'orders3@103-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Order::get_Total()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                !1,
+                                                                                                                                !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders3@103-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders3@103-3' assembly/'orders3@103-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit orders4@111
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders4@111::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders4@111::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Customer,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@112-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,bool>
+  {
+    .field static assembly initonly class assembly/'orders4@112-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Customer c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance string [Utils]Utils/Customer::get_Region()
+      IL_0006:  ldstr      "WA"
+      IL_000b:  call       bool [netstandard]System.String::Equals(string,
+                                                                   string)
+      IL_0010:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders4@112-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders4@112-1' assembly/'orders4@112-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@113-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@113-3'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'orders4@113-3'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg3) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@113-3'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'orders4@113-3'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                     !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@111-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@111-2'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg2) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@111-2'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@111-2'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@111-2'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'orders4@113-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@114-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'orders4@114-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1,
+               valuetype [runtime]System.DateTime V_2,
+               valuetype [runtime]System.DateTime V_3,
+               valuetype [runtime]System.DateTime V_4,
+               valuetype [runtime]System.DateTime V_5,
+               valuetype [runtime]System.DateTime V_6,
+               valuetype [runtime]System.DateTime V_7)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0014:  stloc.2
+      IL_0015:  call       valuetype [runtime]System.DateTime assembly::get_cutOffDate()
+      IL_001a:  stloc.3
+      IL_001b:  ldloc.2
+      IL_001c:  stloc.s    V_4
+      IL_001e:  ldloc.3
+      IL_001f:  stloc.s    V_5
+      IL_0021:  ldloc.s    V_4
+      IL_0023:  stloc.s    V_6
+      IL_0025:  ldloc.s    V_5
+      IL_0027:  stloc.s    V_7
+      IL_0029:  ldloc.s    V_6
+      IL_002b:  ldloc.s    V_7
+      IL_002d:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_0032:  ldc.i4.0
+      IL_0033:  clt
+      IL_0035:  ldc.i4.0
+      IL_0036:  ceq
+      IL_0038:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders4@114-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders4@114-4' assembly/'orders4@114-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@115-5'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`2<string,int32>>
+  {
+    .field static assembly initonly class assembly/'orders4@115-5' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`2<string,int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,int32> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  newobj     instance void class [runtime]System.Tuple`2<string,int32>::.ctor(!0,
+                                                                                             !1)
+      IL_001f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders4@115-5'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders4@115-5' assembly/'orders4@115-5'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numsPlusOne@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<string> productNames@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> strings@26
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> textNums@27
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@34
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,string>[] upperLowerWords@36
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> digitOddEvens@43
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] productInfos@50
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> digits@57
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> lowNums@58
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbersA@67
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbersB@68
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<int32,int32>[] pairs@70
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@79
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] orders@80
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] orders2@89
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> orders3@98
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly valuetype [runtime]System.DateTime cutOffDate@107
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> orders4@109
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@7
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numsPlusOne() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numsPlusOne@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@17
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<string> get_productNames() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::productNames@19
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_strings() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::strings@26
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_textNums() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::textNums@27
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@34
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,string>[] get_upperLowerWords() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,string>[] assembly::upperLowerWords@36
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> get_digitOddEvens() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> assembly::digitOddEvens@43
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] get_productInfos() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] assembly::productInfos@50
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_digits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@57
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_lowNums() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::lowNums@58
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbersA() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbersA@67
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbersB() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbersB@68
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<int32,int32>[] get_pairs() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<int32,int32>[] assembly::pairs@70
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@79
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] get_orders() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] assembly::orders@80
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] get_orders2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::orders2@89
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> get_orders3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> assembly::orders3@98
+    IL_0005:  ret
+  } 
+
+  .method public specialname static valuetype [runtime]System.DateTime get_cutOffDate() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     valuetype [runtime]System.DateTime assembly::cutOffDate@107
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> get_orders4() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> assembly::orders4@109
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_3,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_4,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>> V_5,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_6,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,bool>> V_7,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_8,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>> V_9,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_10,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_11,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_12,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> V_13,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> V_14,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> V_15,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> V_16,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> V_17,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> V_18,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,int32>> V_19,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_20,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> V_21,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_22,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> V_23,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_24,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_25,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_26)
+    IL_0000:  ldc.i4.5
+    IL_0001:  ldc.i4.4
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.3
+    IL_0004:  ldc.i4.s   9
+    IL_0006:  ldc.i4.8
+    IL_0007:  ldc.i4.6
+    IL_0008:  ldc.i4.7
+    IL_0009:  ldc.i4.2
+    IL_000a:  ldc.i4.0
+    IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0010:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0015:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0024:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0029:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0033:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_003d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0042:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@7
+    IL_0047:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_004c:  stloc.1
+    IL_004d:  ldnull
+    IL_004e:  ldc.i4.0
+    IL_004f:  ldc.i4.0
+    IL_0050:  newobj     instance void assembly/'Pipe #1 input at line 11@13'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                            int32,
+                                                                                            int32)
+    IL_0055:  stloc.0
+    IL_0056:  ldloc.0
+    IL_0057:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_005c:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numsPlusOne@10
+    IL_0061:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0066:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@17
+    IL_006b:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0070:  stloc.2
+    IL_0071:  ldnull
+    IL_0072:  ldc.i4.0
+    IL_0073:  ldnull
+    IL_0074:  newobj     instance void assembly/productNames@22::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                              int32,
+                                                                              string)
+    IL_0079:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::productNames@19
+    IL_007e:  ldstr      "zero"
+    IL_0083:  ldstr      "one"
+    IL_0088:  ldstr      "two"
+    IL_008d:  ldstr      "three"
+    IL_0092:  ldstr      "four"
+    IL_0097:  ldstr      "five"
+    IL_009c:  ldstr      "six"
+    IL_00a1:  ldstr      "seven"
+    IL_00a6:  ldstr      "eight"
+    IL_00ab:  ldstr      "nine"
+    IL_00b0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_00b5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00ba:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00bf:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00c4:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00c9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00ce:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00d3:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00d8:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00dd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00e2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00e7:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::strings@26
+    IL_00ec:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00f1:  stloc.s    V_4
+    IL_00f3:  ldnull
+    IL_00f4:  ldc.i4.0
+    IL_00f5:  ldnull
+    IL_00f6:  newobj     instance void assembly/'Pipe #2 input at line 28@30'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                            int32,
+                                                                                            string)
+    IL_00fb:  stloc.3
+    IL_00fc:  ldloc.3
+    IL_00fd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0102:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::textNums@27
+    IL_0107:  ldstr      "aPPLE"
+    IL_010c:  ldstr      "BlUeBeRrY"
+    IL_0111:  ldstr      "cHeRry"
+    IL_0116:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_011b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0120:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0125:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_012a:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@34
+    IL_012f:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0134:  stloc.s    V_6
+    IL_0136:  ldnull
+    IL_0137:  ldc.i4.0
+    IL_0138:  ldnull
+    IL_0139:  newobj     instance void assembly/'Pipe #3 input at line 37@39'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                            int32,
+                                                                                            class [runtime]System.Tuple`2<string,string>)
+    IL_013e:  stloc.s    V_5
+    IL_0140:  ldloc.s    V_5
+    IL_0142:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,string>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0147:  stsfld     class [runtime]System.Tuple`2<string,string>[] assembly::upperLowerWords@36
+    IL_014c:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0151:  stloc.s    V_8
+    IL_0153:  ldnull
+    IL_0154:  ldc.i4.0
+    IL_0155:  ldnull
+    IL_0156:  newobj     instance void assembly/'Pipe #4 input at line 44@46'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                            int32,
+                                                                                            class [runtime]System.Tuple`2<string,bool>)
+    IL_015b:  stloc.s    V_7
+    IL_015d:  ldloc.s    V_7
+    IL_015f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<class [runtime]System.Tuple`2<string,bool>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0164:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> assembly::digitOddEvens@43
+    IL_0169:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_016e:  stloc.s    V_10
+    IL_0170:  ldnull
+    IL_0171:  ldc.i4.0
+    IL_0172:  ldnull
+    IL_0173:  newobj     instance void assembly/'Pipe #5 input at line 51@53'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                            int32,
+                                                                                            class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>)
+    IL_0178:  stloc.s    V_9
+    IL_017a:  ldloc.s    V_9
+    IL_017c:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0181:  stsfld     class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] assembly::productInfos@50
+    IL_0186:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+    IL_018b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@57
+    IL_0190:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0195:  stloc.s    V_12
+    IL_0197:  ldloc.s    V_12
+    IL_0199:  ldloc.s    V_12
+    IL_019b:  ldloc.s    V_12
+    IL_019d:  ldloc.s    V_12
+    IL_019f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+    IL_01a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01a9:  ldloc.s    V_12
+    IL_01ab:  newobj     instance void assembly/'Pipe #6 input at line 59@60'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01b0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,int32,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01b5:  ldsfld     class assembly/'Pipe #6 input at line 59@61-1' assembly/'Pipe #6 input at line 59@61-1'::@_instance
+    IL_01ba:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_01bf:  ldsfld     class assembly/'Pipe #6 input at line 59@62-2' assembly/'Pipe #6 input at line 59@62-2'::@_instance
+    IL_01c4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<int32,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01c9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_01ce:  stloc.s    V_11
+    IL_01d0:  ldloc.s    V_11
+    IL_01d2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01d7:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::lowNums@58
+    IL_01dc:  nop
+    IL_01dd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_lowNums()
+    IL_01e2:  stloc.s    V_13
+    IL_01e4:  ldstr      "four"
+    IL_01e9:  ldstr      "one"
+    IL_01ee:  ldstr      "three"
+    IL_01f3:  ldstr      "two"
+    IL_01f8:  ldstr      "zero"
+    IL_01fd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0202:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0207:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_020c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0211:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0216:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_021b:  stloc.s    V_14
+    IL_021d:  ldloc.s    V_13
+    IL_021f:  stloc.s    V_15
+    IL_0221:  ldloc.s    V_14
+    IL_0223:  stloc.s    V_16
+    IL_0225:  ldloc.s    V_15
+    IL_0227:  stloc.s    V_17
+    IL_0229:  ldloc.s    V_16
+    IL_022b:  stloc.s    V_18
+    IL_022d:  ldloc.s    V_17
+    IL_022f:  ldloc.s    V_18
+    IL_0231:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0236:  callvirt   instance bool class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Equals(object,
+                                                                                                                    class [runtime]System.Collections.IEqualityComparer)
+    IL_023b:  ldc.i4.0
+    IL_023c:  ceq
+    IL_023e:  brfalse.s  IL_025a
+
+    IL_0240:  ldstr      "lowNums failed"
+    IL_0245:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_024a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_024f:  pop
+    IL_0250:  ldc.i4.1
+    IL_0251:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_0256:  pop
+    IL_0257:  nop
+    IL_0258:  br.s       IL_025b
+
+    IL_025a:  nop
+    IL_025b:  ldc.i4.0
+    IL_025c:  ldc.i4.2
+    IL_025d:  ldc.i4.4
+    IL_025e:  ldc.i4.5
+    IL_025f:  ldc.i4.6
+    IL_0260:  ldc.i4.8
+    IL_0261:  ldc.i4.s   9
+    IL_0263:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0268:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_026d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0272:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0277:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_027c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0281:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0286:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_028b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbersA@67
+    IL_0290:  ldc.i4.1
+    IL_0291:  ldc.i4.3
+    IL_0292:  ldc.i4.5
+    IL_0293:  ldc.i4.7
+    IL_0294:  ldc.i4.8
+    IL_0295:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_029a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_029f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_02a4:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_02a9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_02ae:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_02b3:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbersB@68
+    IL_02b8:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_02bd:  stloc.s    V_20
+    IL_02bf:  ldloc.s    V_20
+    IL_02c1:  ldloc.s    V_20
+    IL_02c3:  ldloc.s    V_20
+    IL_02c5:  ldloc.s    V_20
+    IL_02c7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbersA()
+    IL_02cc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_02d1:  ldloc.s    V_20
+    IL_02d3:  newobj     instance void assembly/'Pipe #7 input at line 71@72'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_02d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_02dd:  ldsfld     class assembly/'Pipe #7 input at line 71@74-2' assembly/'Pipe #7 input at line 71@74-2'::@_instance
+    IL_02e2:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_02e7:  ldsfld     class assembly/'Pipe #7 input at line 71@75-3' assembly/'Pipe #7 input at line 71@75-3'::@_instance
+    IL_02ec:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,int32>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_02f1:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_02f6:  stloc.s    V_19
+    IL_02f8:  ldloc.s    V_19
+    IL_02fa:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<int32,int32>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_02ff:  stsfld     class [runtime]System.Tuple`2<int32,int32>[] assembly::pairs@70
+    IL_0304:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_0309:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@79
+    IL_030e:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0313:  stloc.s    V_22
+    IL_0315:  ldloc.s    V_22
+    IL_0317:  ldloc.s    V_22
+    IL_0319:  ldloc.s    V_22
+    IL_031b:  ldloc.s    V_22
+    IL_031d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_0322:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0327:  ldloc.s    V_22
+    IL_0329:  newobj     instance void assembly/'Pipe #8 input at line 81@82'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_032e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0333:  ldsfld     class assembly/'Pipe #8 input at line 81@84-2' assembly/'Pipe #8 input at line 81@84-2'::@_instance
+    IL_0338:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_033d:  ldsfld     class assembly/'Pipe #8 input at line 81@85-3' assembly/'Pipe #8 input at line 81@85-3'::@_instance
+    IL_0342:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0347:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_034c:  stloc.s    V_21
+    IL_034e:  ldloc.s    V_21
+    IL_0350:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0355:  stsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] assembly::orders@80
+    IL_035a:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_035f:  stloc.s    V_24
+    IL_0361:  ldloc.s    V_24
+    IL_0363:  ldloc.s    V_24
+    IL_0365:  ldloc.s    V_24
+    IL_0367:  ldloc.s    V_24
+    IL_0369:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_036e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0373:  ldloc.s    V_24
+    IL_0375:  newobj     instance void assembly/'Pipe #9 input at line 90@91'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_037a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_037f:  ldsfld     class assembly/'Pipe #9 input at line 90@93-2' assembly/'Pipe #9 input at line 90@93-2'::@_instance
+    IL_0384:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0389:  ldsfld     class assembly/'Pipe #9 input at line 90@94-3' assembly/'Pipe #9 input at line 90@94-3'::@_instance
+    IL_038e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0393:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0398:  stloc.s    V_23
+    IL_039a:  ldloc.s    V_23
+    IL_039c:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_03a1:  stsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::orders2@89
+    IL_03a6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_03ab:  stloc.s    V_25
+    IL_03ad:  ldloc.s    V_25
+    IL_03af:  ldloc.s    V_25
+    IL_03b1:  ldloc.s    V_25
+    IL_03b3:  ldloc.s    V_25
+    IL_03b5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_03ba:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_03bf:  ldloc.s    V_25
+    IL_03c1:  newobj     instance void assembly/orders3@100::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_03c6:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_03cb:  ldsfld     class assembly/'orders3@102-2' assembly/'orders3@102-2'::@_instance
+    IL_03d0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_03d5:  ldsfld     class assembly/'orders3@103-3' assembly/'orders3@103-3'::@_instance
+    IL_03da:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_03df:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_03e4:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> assembly::orders3@98
+    IL_03e9:  ldc.i4     0x7cd
+    IL_03ee:  ldc.i4.1
+    IL_03ef:  ldc.i4.1
+    IL_03f0:  newobj     instance void [runtime]System.DateTime::.ctor(int32,
+                                                                        int32,
+                                                                        int32)
+    IL_03f5:  stsfld     valuetype [runtime]System.DateTime assembly::cutOffDate@107
+    IL_03fa:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_03ff:  stloc.s    V_26
+    IL_0401:  ldloc.s    V_26
+    IL_0403:  ldloc.s    V_26
+    IL_0405:  ldloc.s    V_26
+    IL_0407:  ldloc.s    V_26
+    IL_0409:  ldloc.s    V_26
+    IL_040b:  ldloc.s    V_26
+    IL_040d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_0412:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0417:  ldloc.s    V_26
+    IL_0419:  newobj     instance void assembly/orders4@111::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_041e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Customer,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0423:  ldsfld     class assembly/'orders4@112-1' assembly/'orders4@112-1'::@_instance
+    IL_0428:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_042d:  ldloc.s    V_26
+    IL_042f:  newobj     instance void assembly/'orders4@111-2'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0434:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0439:  ldsfld     class assembly/'orders4@114-4' assembly/'orders4@114-4'::@_instance
+    IL_043e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0443:  ldsfld     class assembly/'orders4@115-5' assembly/'orders4@115-5'::@_instance
+    IL_0448:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,int32>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_044d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,int32>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0452:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> assembly::orders4@109
+    IL_0457:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numsPlusOne()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numsPlusOne()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<string>
+          productNames()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::get_productNames()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          strings()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          textNums()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_textNums()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property class [runtime]System.Tuple`2<string,string>[]
+          upperLowerWords()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,string>[] assembly::get_upperLowerWords()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>>
+          digitOddEvens()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> assembly::get_digitOddEvens()
+  } 
+  .property class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[]
+          productInfos()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] assembly::get_productInfos()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          digits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          lowNums()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_lowNums()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbersA()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbersA()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbersB()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbersB()
+  } 
+  .property class [runtime]System.Tuple`2<int32,int32>[]
+          pairs()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<int32,int32>[] assembly::get_pairs()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[]
+          orders()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] assembly::get_orders()
+  } 
+  .property class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[]
+          orders2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::get_orders2()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>
+          orders3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> assembly::get_orders3()
+  } 
+  .property valuetype [runtime]System.DateTime
+          cutOffDate()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get valuetype [runtime]System.DateTime assembly::get_cutOffDate()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>>
+          orders4()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> assembly::get_orders4()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOn.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOn.il.net472.release.bsl
new file mode 100644
index 00000000000..bc17e422cd1
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOn.il.net472.release.bsl
@@ -0,0 +1,3816 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 11@12-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 11@12-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<int32> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<int32>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 11@12-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 11@12-1' assembly/'Pipe #1 input at line 11@12-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 11@13'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0073
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0066
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0094
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'Pipe #1 input at line 11@12-1' assembly/'Pipe #1 input at line 11@12-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                   class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0046:  br.s       IL_0066
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  ldc.i4.1
+      IL_005e:  add
+      IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+      IL_0064:  ldc.i4.1
+      IL_0065:  ret
+
+      IL_0066:  ldarg.0
+      IL_0067:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_006c:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0071:  brtrue.s   IL_0048
+
+      IL_0073:  ldarg.0
+      IL_0074:  ldc.i4.3
+      IL_0075:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_007a:  ldarg.0
+      IL_007b:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_0080:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_0085:  nop
+      IL_0086:  ldarg.0
+      IL_0087:  ldnull
+      IL_0088:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_008d:  ldarg.0
+      IL_008e:  ldc.i4.3
+      IL_008f:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0094:  ldarg.0
+      IL_0095:  ldc.i4.0
+      IL_0096:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+      IL_009b:  ldc.i4.0
+      IL_009c:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 11@13'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                              int32,
+                                                                                              int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'productNames@21-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'productNames@21-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Product>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'productNames@21-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'productNames@21-1' assembly/'productNames@21-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname productNames@22
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/productNames@22::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/productNames@22::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productNames@22::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0076
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0069
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0097
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'productNames@21-1' assembly/'productNames@21-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                  class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/productNames@22::pc
+      IL_0046:  br.s       IL_0069
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/productNames@22::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0062:  stfld      string assembly/productNames@22::current
+      IL_0067:  ldc.i4.1
+      IL_0068:  ret
+
+      IL_0069:  ldarg.0
+      IL_006a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_006f:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0074:  brtrue.s   IL_0048
+
+      IL_0076:  ldarg.0
+      IL_0077:  ldc.i4.3
+      IL_0078:  stfld      int32 assembly/productNames@22::pc
+      IL_007d:  ldarg.0
+      IL_007e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_0083:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_0088:  nop
+      IL_0089:  ldarg.0
+      IL_008a:  ldnull
+      IL_008b:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_0090:  ldarg.0
+      IL_0091:  ldc.i4.3
+      IL_0092:  stfld      int32 assembly/productNames@22::pc
+      IL_0097:  ldarg.0
+      IL_0098:  ldnull
+      IL_0099:  stfld      string assembly/productNames@22::current
+      IL_009e:  ldc.i4.0
+      IL_009f:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productNames@22::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/productNames@22::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/productNames@22::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/productNames@22::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/productNames@22::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productNames@22::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/productNames@22::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/productNames@22::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                int32,
+                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 28@29-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 28@29-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<int32> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<int32>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 28@29-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 28@29-1' assembly/'Pipe #2 input at line 28@29-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #2 input at line 28@30'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #2 input at line 28@30'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_007b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_006e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_009c
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'Pipe #2 input at line 28@29-1' assembly/'Pipe #2 input at line 28@29-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                   class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0046:  br.s       IL_006e
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_005b:  ldarg.0
+      IL_005c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+      IL_0061:  ldloc.0
+      IL_0062:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Item(int32)
+      IL_0067:  stfld      string assembly/'Pipe #2 input at line 28@30'::current
+      IL_006c:  ldc.i4.1
+      IL_006d:  ret
+
+      IL_006e:  ldarg.0
+      IL_006f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_0074:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0079:  brtrue.s   IL_0048
+
+      IL_007b:  ldarg.0
+      IL_007c:  ldc.i4.3
+      IL_007d:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0082:  ldarg.0
+      IL_0083:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_0088:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_008d:  nop
+      IL_008e:  ldarg.0
+      IL_008f:  ldnull
+      IL_0090:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_0095:  ldarg.0
+      IL_0096:  ldc.i4.3
+      IL_0097:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_009c:  ldarg.0
+      IL_009d:  ldnull
+      IL_009e:  stfld      string assembly/'Pipe #2 input at line 28@30'::current
+      IL_00a3:  ldc.i4.0
+      IL_00a4:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #2 input at line 28@30'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #2 input at line 28@30'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #2 input at line 28@30'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                              int32,
+                                                                                              string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 37@38-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 37@38-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<string> Invoke(string _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (string V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<string>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 37@38-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 37@38-1' assembly/'Pipe #3 input at line 37@38-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #3 input at line 37@39'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<string,string>>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Tuple`2<string,string> current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 class [runtime]System.Tuple`2<string,string> current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<string,string>>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (string V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0027
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0084
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0077
+
+      IL_0021:  nop
+      IL_0022:  br         IL_00a5
+
+      IL_0027:  nop
+      IL_0028:  ldarg.0
+      IL_0029:  ldsfld     class assembly/'Pipe #3 input at line 37@38-1' assembly/'Pipe #3 input at line 37@38-1'::@_instance
+      IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_0033:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>,string>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                      class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0038:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_003d:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_0042:  ldarg.0
+      IL_0043:  ldc.i4.1
+      IL_0044:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_0049:  br.s       IL_0077
+
+      IL_004b:  ldarg.0
+      IL_004c:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_0051:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_0056:  stloc.0
+      IL_0057:  ldarg.0
+      IL_0058:  ldc.i4.2
+      IL_0059:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_005e:  ldarg.0
+      IL_005f:  ldloc.0
+      IL_0060:  callvirt   instance string [runtime]System.String::ToUpper()
+      IL_0065:  ldloc.0
+      IL_0066:  callvirt   instance string [runtime]System.String::ToLower()
+      IL_006b:  newobj     instance void class [runtime]System.Tuple`2<string,string>::.ctor(!0,
+                                                                                              !1)
+      IL_0070:  stfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+      IL_0075:  ldc.i4.1
+      IL_0076:  ret
+
+      IL_0077:  ldarg.0
+      IL_0078:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_007d:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0082:  brtrue.s   IL_004b
+
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_0091:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_0096:  nop
+      IL_0097:  ldarg.0
+      IL_0098:  ldnull
+      IL_0099:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_009e:  ldarg.0
+      IL_009f:  ldc.i4.3
+      IL_00a0:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_00a5:  ldarg.0
+      IL_00a6:  ldnull
+      IL_00a7:  stfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+      IL_00ac:  ldc.i4.0
+      IL_00ad:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,string> get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<string,string>> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #3 input at line 37@39'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                              int32,
+                                                                                              class [runtime]System.Tuple`2<string,string>)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 44@45-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 44@45-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<int32> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<int32>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 44@45-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 44@45-1' assembly/'Pipe #4 input at line 44@45-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #4 input at line 44@46'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<string,bool>>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Tuple`2<string,bool> current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 class [runtime]System.Tuple`2<string,bool> current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<string,bool>>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,bool>>& next) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0027
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0089
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_007c
+
+      IL_0021:  nop
+      IL_0022:  br         IL_00aa
+
+      IL_0027:  nop
+      IL_0028:  ldarg.0
+      IL_0029:  ldsfld     class assembly/'Pipe #4 input at line 44@45-1' assembly/'Pipe #4 input at line 44@45-1'::@_instance
+      IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_0033:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                   class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0038:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_003d:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0042:  ldarg.0
+      IL_0043:  ldc.i4.1
+      IL_0044:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0049:  br.s       IL_007c
+
+      IL_004b:  ldarg.0
+      IL_004c:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0051:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0056:  stloc.0
+      IL_0057:  ldarg.0
+      IL_0058:  ldc.i4.2
+      IL_0059:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_005e:  ldarg.0
+      IL_005f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+      IL_0064:  ldloc.0
+      IL_0065:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Item(int32)
+      IL_006a:  ldloc.0
+      IL_006b:  ldc.i4.2
+      IL_006c:  rem
+      IL_006d:  ldc.i4.0
+      IL_006e:  ceq
+      IL_0070:  newobj     instance void class [runtime]System.Tuple`2<string,bool>::.ctor(!0,
+                                                                                            !1)
+      IL_0075:  stfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+      IL_007a:  ldc.i4.1
+      IL_007b:  ret
+
+      IL_007c:  ldarg.0
+      IL_007d:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0082:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0087:  brtrue.s   IL_004b
+
+      IL_0089:  ldarg.0
+      IL_008a:  ldc.i4.3
+      IL_008b:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0090:  ldarg.0
+      IL_0091:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0096:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_009b:  nop
+      IL_009c:  ldarg.0
+      IL_009d:  ldnull
+      IL_009e:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_00a3:  ldarg.0
+      IL_00a4:  ldc.i4.3
+      IL_00a5:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_00aa:  ldarg.0
+      IL_00ab:  ldnull
+      IL_00ac:  stfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+      IL_00b1:  ldc.i4.0
+      IL_00b2:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,bool> get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<string,bool>> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #4 input at line 44@46'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                              int32,
+                                                                                              class [runtime]System.Tuple`2<string,bool>)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 51@52-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 51@52-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Product>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 51@52-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 51@52-1' assembly/'Pipe #5 input at line 51@52-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #5 input at line 51@53'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>>& next) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0027
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_008a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_007d
+
+      IL_0021:  nop
+      IL_0022:  br         IL_00ab
+
+      IL_0027:  nop
+      IL_0028:  ldarg.0
+      IL_0029:  ldsfld     class assembly/'Pipe #5 input at line 51@52-1' assembly/'Pipe #5 input at line 51@52-1'::@_instance
+      IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_0033:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                  class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0038:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_003d:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0042:  ldarg.0
+      IL_0043:  ldc.i4.1
+      IL_0044:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0049:  br.s       IL_007d
+
+      IL_004b:  ldarg.0
+      IL_004c:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0051:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_0056:  stloc.0
+      IL_0057:  ldarg.0
+      IL_0058:  ldc.i4.2
+      IL_0059:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_005e:  ldarg.0
+      IL_005f:  ldloc.0
+      IL_0060:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0065:  ldloc.0
+      IL_0066:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_006b:  ldloc.0
+      IL_006c:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0071:  newobj     instance void class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                 !1,
+                                                                                                                                 !2)
+      IL_0076:  stfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+      IL_007b:  ldc.i4.1
+      IL_007c:  ret
+
+      IL_007d:  ldarg.0
+      IL_007e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0083:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0088:  brtrue.s   IL_004b
+
+      IL_008a:  ldarg.0
+      IL_008b:  ldc.i4.3
+      IL_008c:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0091:  ldarg.0
+      IL_0092:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0097:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_009c:  nop
+      IL_009d:  ldarg.0
+      IL_009e:  ldnull
+      IL_009f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_00a4:  ldarg.0
+      IL_00a5:  ldc.i4.3
+      IL_00a6:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_00ab:  ldarg.0
+      IL_00ac:  ldnull
+      IL_00ad:  stfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+      IL_00b2:  ldc.i4.0
+      IL_00b3:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #5 input at line 51@53'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                              int32,
+                                                                                              class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@60'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 59@60'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 59@60'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<int32,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@61-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@61-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.5
+      IL_0002:  clt
+      IL_0004:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@61-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@61-1' assembly/'Pipe #6 input at line 59@61-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@62-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@62-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+      IL_0005:  ldarg.1
+      IL_0006:  tail.
+      IL_0008:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Item(int32)
+      IL_000d:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@62-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@62-2' assembly/'Pipe #6 input at line 59@62-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 71@73-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 a
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 int32 a) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@73-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      int32 assembly/'Pipe #7 input at line 71@73-1'::a
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,object> Invoke(int32 _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@73-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      int32 assembly/'Pipe #7 input at line 71@73-1'::a
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<int32,int32>::.ctor(!0,
+                                                                                            !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<int32,int32>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 71@72'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@72'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@72'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@72'::builder@
+      IL_000e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbersB()
+      IL_0013:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0018:  ldarg.0
+      IL_0019:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@72'::builder@
+      IL_001e:  ldloc.0
+      IL_001f:  newobj     instance void assembly/'Pipe #7 input at line 71@73-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                int32)
+      IL_0024:  tail.
+      IL_0026:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,int32>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 71@74-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<int32,int32>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 71@74-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<int32,int32>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<int32,int32> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<int32,int32>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<int32,int32>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  clt
+      IL_0012:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 71@74-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 71@74-2' assembly/'Pipe #7 input at line 71@74-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 71@75-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Tuple`2<int32,int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 71@75-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Tuple`2<int32,int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,int32> Invoke(class [runtime]System.Tuple`2<int32,int32> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<int32,int32>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<int32,int32>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  newobj     instance void class [runtime]System.Tuple`2<int32,int32>::.ctor(!0,
+                                                                                            !1)
+      IL_0015:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 71@75-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 71@75-3' assembly/'Pipe #7 input at line 71@75-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #8 input at line 81@83-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@83-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'Pipe #8 input at line 81@83-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@83-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'Pipe #8 input at line 81@83-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                     !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #8 input at line 81@82'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@82'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@82'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@82'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@82'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'Pipe #8 input at line 81@83-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #8 input at line 81@84-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #8 input at line 81@84-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Order::get_Total()
+      IL_0014:  ldc.i4     0xc350
+      IL_0019:  ldc.i4.0
+      IL_001a:  ldc.i4.0
+      IL_001b:  ldc.i4.0
+      IL_001c:  ldc.i4.2
+      IL_001d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                            int32,
+                                                                            int32,
+                                                                            bool,
+                                                                            uint8)
+      IL_0022:  call       bool [netstandard]System.Decimal::op_LessThan(valuetype [netstandard]System.Decimal,
+                                                                         valuetype [netstandard]System.Decimal)
+      IL_0027:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #8 input at line 81@84-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #8 input at line 81@84-2' assembly/'Pipe #8 input at line 81@84-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #8 input at line 81@85-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'Pipe #8 input at line 81@85-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Order::get_Total()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                !1,
+                                                                                                                                !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #8 input at line 81@85-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #8 input at line 81@85-3' assembly/'Pipe #8 input at line 81@85-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #9 input at line 90@92-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@92-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'Pipe #9 input at line 90@92-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@92-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'Pipe #9 input at line 90@92-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                     !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #9 input at line 90@91'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@91'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@91'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@91'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@91'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'Pipe #9 input at line 90@92-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #9 input at line 90@93-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #9 input at line 90@93-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1,
+               valuetype [runtime]System.DateTime V_2,
+               valuetype [runtime]System.DateTime V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0014:  stloc.2
+      IL_0015:  ldc.i4     0x7ce
+      IL_001a:  ldc.i4.1
+      IL_001b:  ldc.i4.1
+      IL_001c:  newobj     instance void [runtime]System.DateTime::.ctor(int32,
+                                                                          int32,
+                                                                          int32)
+      IL_0021:  stloc.3
+      IL_0022:  ldloc.2
+      IL_0023:  ldloc.3
+      IL_0024:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_0029:  ldc.i4.0
+      IL_002a:  clt
+      IL_002c:  ldc.i4.0
+      IL_002d:  ceq
+      IL_002f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #9 input at line 90@93-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #9 input at line 90@93-2' assembly/'Pipe #9 input at line 90@93-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #9 input at line 90@94-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>
+  {
+    .field static assembly initonly class assembly/'Pipe #9 input at line 90@94-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>::.ctor(!0,
+                                                                                                                                 !1,
+                                                                                                                                 !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #9 input at line 90@94-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #9 input at line 90@94-3' assembly/'Pipe #9 input at line 90@94-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders3@101-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders3@101-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'orders3@101-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders3@101-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'orders3@101-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                     !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit orders3@100
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders3@100::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders3@100::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders3@100::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders3@100::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'orders3@101-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders3@102-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'orders3@102-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Order::get_Total()
+      IL_0014:  ldc.i4     0x4e20
+      IL_0019:  ldc.i4.0
+      IL_001a:  ldc.i4.0
+      IL_001b:  ldc.i4.0
+      IL_001c:  ldc.i4.1
+      IL_001d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                            int32,
+                                                                            int32,
+                                                                            bool,
+                                                                            uint8)
+      IL_0022:  call       bool [netstandard]System.Decimal::op_GreaterThanOrEqual(valuetype [netstandard]System.Decimal,
+                                                                                   valuetype [netstandard]System.Decimal)
+      IL_0027:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders3@102-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders3@102-2' assembly/'orders3@102-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders3@103-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'orders3@103-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Order::get_Total()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                !1,
+                                                                                                                                !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders3@103-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders3@103-3' assembly/'orders3@103-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit orders4@111
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders4@111::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders4@111::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Customer,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@112-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,bool>
+  {
+    .field static assembly initonly class assembly/'orders4@112-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Customer c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance string [Utils]Utils/Customer::get_Region()
+      IL_0006:  ldstr      "WA"
+      IL_000b:  call       bool [netstandard]System.String::Equals(string,
+                                                                   string)
+      IL_0010:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders4@112-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders4@112-1' assembly/'orders4@112-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@113-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@113-3'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'orders4@113-3'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg3) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@113-3'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'orders4@113-3'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                     !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@111-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@111-2'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg2) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@111-2'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@111-2'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@111-2'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'orders4@113-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@114-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'orders4@114-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1,
+               valuetype [runtime]System.DateTime V_2,
+               valuetype [runtime]System.DateTime V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0014:  stloc.2
+      IL_0015:  call       valuetype [runtime]System.DateTime assembly::get_cutOffDate()
+      IL_001a:  stloc.3
+      IL_001b:  ldloc.2
+      IL_001c:  ldloc.3
+      IL_001d:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_0022:  ldc.i4.0
+      IL_0023:  clt
+      IL_0025:  ldc.i4.0
+      IL_0026:  ceq
+      IL_0028:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders4@114-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders4@114-4' assembly/'orders4@114-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@115-5'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`2<string,int32>>
+  {
+    .field static assembly initonly class assembly/'orders4@115-5' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`2<string,int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,int32> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  newobj     instance void class [runtime]System.Tuple`2<string,int32>::.ctor(!0,
+                                                                                             !1)
+      IL_001f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders4@115-5'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders4@115-5' assembly/'orders4@115-5'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numsPlusOne@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<string> productNames@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> strings@26
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> textNums@27
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@34
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,string>[] upperLowerWords@36
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> digitOddEvens@43
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] productInfos@50
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> digits@57
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> lowNums@58
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbersA@67
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbersB@68
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<int32,int32>[] pairs@70
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@79
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] orders@80
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] orders2@89
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> orders3@98
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly valuetype [runtime]System.DateTime cutOffDate@107
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> orders4@109
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@7
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numsPlusOne() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numsPlusOne@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@17
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<string> get_productNames() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::productNames@19
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_strings() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::strings@26
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_textNums() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::textNums@27
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@34
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,string>[] get_upperLowerWords() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,string>[] assembly::upperLowerWords@36
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> get_digitOddEvens() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> assembly::digitOddEvens@43
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] get_productInfos() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] assembly::productInfos@50
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_digits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@57
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_lowNums() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::lowNums@58
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbersA() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbersA@67
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbersB() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbersB@68
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<int32,int32>[] get_pairs() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<int32,int32>[] assembly::pairs@70
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@79
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] get_orders() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] assembly::orders@80
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] get_orders2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::orders2@89
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> get_orders3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> assembly::orders3@98
+    IL_0005:  ret
+  } 
+
+  .method public specialname static valuetype [runtime]System.DateTime get_cutOffDate() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     valuetype [runtime]System.DateTime assembly::cutOffDate@107
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> get_orders4() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> assembly::orders4@109
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_3,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_4,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>> V_5,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_6,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,bool>> V_7,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_8,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>> V_9,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_10,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_11,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_12,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> V_13,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> V_14,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,int32>> V_15,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_16,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> V_17,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_18,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> V_19,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_20,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_21,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_22)
+    IL_0000:  ldc.i4.5
+    IL_0001:  ldc.i4.4
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.3
+    IL_0004:  ldc.i4.s   9
+    IL_0006:  ldc.i4.8
+    IL_0007:  ldc.i4.6
+    IL_0008:  ldc.i4.7
+    IL_0009:  ldc.i4.2
+    IL_000a:  ldc.i4.0
+    IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0010:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0015:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0024:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0029:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0033:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_003d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0042:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@7
+    IL_0047:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_004c:  stloc.1
+    IL_004d:  ldnull
+    IL_004e:  ldc.i4.0
+    IL_004f:  ldc.i4.0
+    IL_0050:  newobj     instance void assembly/'Pipe #1 input at line 11@13'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                            int32,
+                                                                                            int32)
+    IL_0055:  stloc.0
+    IL_0056:  ldloc.0
+    IL_0057:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_005c:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numsPlusOne@10
+    IL_0061:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0066:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@17
+    IL_006b:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0070:  stloc.2
+    IL_0071:  ldnull
+    IL_0072:  ldc.i4.0
+    IL_0073:  ldnull
+    IL_0074:  newobj     instance void assembly/productNames@22::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                              int32,
+                                                                              string)
+    IL_0079:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::productNames@19
+    IL_007e:  ldstr      "zero"
+    IL_0083:  ldstr      "one"
+    IL_0088:  ldstr      "two"
+    IL_008d:  ldstr      "three"
+    IL_0092:  ldstr      "four"
+    IL_0097:  ldstr      "five"
+    IL_009c:  ldstr      "six"
+    IL_00a1:  ldstr      "seven"
+    IL_00a6:  ldstr      "eight"
+    IL_00ab:  ldstr      "nine"
+    IL_00b0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_00b5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00ba:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00bf:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00c4:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00c9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00ce:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00d3:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00d8:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00dd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00e2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00e7:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::strings@26
+    IL_00ec:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00f1:  stloc.s    V_4
+    IL_00f3:  ldnull
+    IL_00f4:  ldc.i4.0
+    IL_00f5:  ldnull
+    IL_00f6:  newobj     instance void assembly/'Pipe #2 input at line 28@30'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                            int32,
+                                                                                            string)
+    IL_00fb:  stloc.3
+    IL_00fc:  ldloc.3
+    IL_00fd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0102:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::textNums@27
+    IL_0107:  ldstr      "aPPLE"
+    IL_010c:  ldstr      "BlUeBeRrY"
+    IL_0111:  ldstr      "cHeRry"
+    IL_0116:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_011b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0120:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0125:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_012a:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@34
+    IL_012f:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0134:  stloc.s    V_6
+    IL_0136:  ldnull
+    IL_0137:  ldc.i4.0
+    IL_0138:  ldnull
+    IL_0139:  newobj     instance void assembly/'Pipe #3 input at line 37@39'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                            int32,
+                                                                                            class [runtime]System.Tuple`2<string,string>)
+    IL_013e:  stloc.s    V_5
+    IL_0140:  ldloc.s    V_5
+    IL_0142:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,string>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0147:  stsfld     class [runtime]System.Tuple`2<string,string>[] assembly::upperLowerWords@36
+    IL_014c:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0151:  stloc.s    V_8
+    IL_0153:  ldnull
+    IL_0154:  ldc.i4.0
+    IL_0155:  ldnull
+    IL_0156:  newobj     instance void assembly/'Pipe #4 input at line 44@46'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                            int32,
+                                                                                            class [runtime]System.Tuple`2<string,bool>)
+    IL_015b:  stloc.s    V_7
+    IL_015d:  ldloc.s    V_7
+    IL_015f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<class [runtime]System.Tuple`2<string,bool>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0164:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> assembly::digitOddEvens@43
+    IL_0169:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_016e:  stloc.s    V_10
+    IL_0170:  ldnull
+    IL_0171:  ldc.i4.0
+    IL_0172:  ldnull
+    IL_0173:  newobj     instance void assembly/'Pipe #5 input at line 51@53'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                            int32,
+                                                                                            class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>)
+    IL_0178:  stloc.s    V_9
+    IL_017a:  ldloc.s    V_9
+    IL_017c:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0181:  stsfld     class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] assembly::productInfos@50
+    IL_0186:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+    IL_018b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@57
+    IL_0190:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0195:  stloc.s    V_12
+    IL_0197:  ldloc.s    V_12
+    IL_0199:  ldloc.s    V_12
+    IL_019b:  ldloc.s    V_12
+    IL_019d:  ldloc.s    V_12
+    IL_019f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+    IL_01a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01a9:  ldloc.s    V_12
+    IL_01ab:  newobj     instance void assembly/'Pipe #6 input at line 59@60'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01b0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,int32,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01b5:  ldsfld     class assembly/'Pipe #6 input at line 59@61-1' assembly/'Pipe #6 input at line 59@61-1'::@_instance
+    IL_01ba:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_01bf:  ldsfld     class assembly/'Pipe #6 input at line 59@62-2' assembly/'Pipe #6 input at line 59@62-2'::@_instance
+    IL_01c4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<int32,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01c9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_01ce:  stloc.s    V_11
+    IL_01d0:  ldloc.s    V_11
+    IL_01d2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01d7:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::lowNums@58
+    IL_01dc:  nop
+    IL_01dd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_lowNums()
+    IL_01e2:  stloc.s    V_13
+    IL_01e4:  ldstr      "four"
+    IL_01e9:  ldstr      "one"
+    IL_01ee:  ldstr      "three"
+    IL_01f3:  ldstr      "two"
+    IL_01f8:  ldstr      "zero"
+    IL_01fd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0202:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0207:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_020c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0211:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0216:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_021b:  stloc.s    V_14
+    IL_021d:  ldloc.s    V_13
+    IL_021f:  ldloc.s    V_14
+    IL_0221:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0226:  callvirt   instance bool class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Equals(object,
+                                                                                                                    class [runtime]System.Collections.IEqualityComparer)
+    IL_022b:  ldc.i4.0
+    IL_022c:  ceq
+    IL_022e:  brfalse.s  IL_024a
+
+    IL_0230:  ldstr      "lowNums failed"
+    IL_0235:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_023a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_023f:  pop
+    IL_0240:  ldc.i4.1
+    IL_0241:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_0246:  pop
+    IL_0247:  nop
+    IL_0248:  br.s       IL_024b
+
+    IL_024a:  nop
+    IL_024b:  ldc.i4.0
+    IL_024c:  ldc.i4.2
+    IL_024d:  ldc.i4.4
+    IL_024e:  ldc.i4.5
+    IL_024f:  ldc.i4.6
+    IL_0250:  ldc.i4.8
+    IL_0251:  ldc.i4.s   9
+    IL_0253:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0258:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_025d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0262:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0267:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_026c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0271:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0276:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_027b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbersA@67
+    IL_0280:  ldc.i4.1
+    IL_0281:  ldc.i4.3
+    IL_0282:  ldc.i4.5
+    IL_0283:  ldc.i4.7
+    IL_0284:  ldc.i4.8
+    IL_0285:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_028a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_028f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0294:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0299:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_029e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_02a3:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbersB@68
+    IL_02a8:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_02ad:  stloc.s    V_16
+    IL_02af:  ldloc.s    V_16
+    IL_02b1:  ldloc.s    V_16
+    IL_02b3:  ldloc.s    V_16
+    IL_02b5:  ldloc.s    V_16
+    IL_02b7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbersA()
+    IL_02bc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_02c1:  ldloc.s    V_16
+    IL_02c3:  newobj     instance void assembly/'Pipe #7 input at line 71@72'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_02c8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_02cd:  ldsfld     class assembly/'Pipe #7 input at line 71@74-2' assembly/'Pipe #7 input at line 71@74-2'::@_instance
+    IL_02d2:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_02d7:  ldsfld     class assembly/'Pipe #7 input at line 71@75-3' assembly/'Pipe #7 input at line 71@75-3'::@_instance
+    IL_02dc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,int32>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_02e1:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_02e6:  stloc.s    V_15
+    IL_02e8:  ldloc.s    V_15
+    IL_02ea:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<int32,int32>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_02ef:  stsfld     class [runtime]System.Tuple`2<int32,int32>[] assembly::pairs@70
+    IL_02f4:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_02f9:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@79
+    IL_02fe:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0303:  stloc.s    V_18
+    IL_0305:  ldloc.s    V_18
+    IL_0307:  ldloc.s    V_18
+    IL_0309:  ldloc.s    V_18
+    IL_030b:  ldloc.s    V_18
+    IL_030d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_0312:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0317:  ldloc.s    V_18
+    IL_0319:  newobj     instance void assembly/'Pipe #8 input at line 81@82'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_031e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0323:  ldsfld     class assembly/'Pipe #8 input at line 81@84-2' assembly/'Pipe #8 input at line 81@84-2'::@_instance
+    IL_0328:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_032d:  ldsfld     class assembly/'Pipe #8 input at line 81@85-3' assembly/'Pipe #8 input at line 81@85-3'::@_instance
+    IL_0332:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0337:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_033c:  stloc.s    V_17
+    IL_033e:  ldloc.s    V_17
+    IL_0340:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0345:  stsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] assembly::orders@80
+    IL_034a:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_034f:  stloc.s    V_20
+    IL_0351:  ldloc.s    V_20
+    IL_0353:  ldloc.s    V_20
+    IL_0355:  ldloc.s    V_20
+    IL_0357:  ldloc.s    V_20
+    IL_0359:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_035e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0363:  ldloc.s    V_20
+    IL_0365:  newobj     instance void assembly/'Pipe #9 input at line 90@91'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_036a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_036f:  ldsfld     class assembly/'Pipe #9 input at line 90@93-2' assembly/'Pipe #9 input at line 90@93-2'::@_instance
+    IL_0374:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0379:  ldsfld     class assembly/'Pipe #9 input at line 90@94-3' assembly/'Pipe #9 input at line 90@94-3'::@_instance
+    IL_037e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0383:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0388:  stloc.s    V_19
+    IL_038a:  ldloc.s    V_19
+    IL_038c:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0391:  stsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::orders2@89
+    IL_0396:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_039b:  stloc.s    V_21
+    IL_039d:  ldloc.s    V_21
+    IL_039f:  ldloc.s    V_21
+    IL_03a1:  ldloc.s    V_21
+    IL_03a3:  ldloc.s    V_21
+    IL_03a5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_03aa:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_03af:  ldloc.s    V_21
+    IL_03b1:  newobj     instance void assembly/orders3@100::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_03b6:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_03bb:  ldsfld     class assembly/'orders3@102-2' assembly/'orders3@102-2'::@_instance
+    IL_03c0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_03c5:  ldsfld     class assembly/'orders3@103-3' assembly/'orders3@103-3'::@_instance
+    IL_03ca:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_03cf:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_03d4:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> assembly::orders3@98
+    IL_03d9:  ldc.i4     0x7cd
+    IL_03de:  ldc.i4.1
+    IL_03df:  ldc.i4.1
+    IL_03e0:  newobj     instance void [runtime]System.DateTime::.ctor(int32,
+                                                                        int32,
+                                                                        int32)
+    IL_03e5:  stsfld     valuetype [runtime]System.DateTime assembly::cutOffDate@107
+    IL_03ea:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_03ef:  stloc.s    V_22
+    IL_03f1:  ldloc.s    V_22
+    IL_03f3:  ldloc.s    V_22
+    IL_03f5:  ldloc.s    V_22
+    IL_03f7:  ldloc.s    V_22
+    IL_03f9:  ldloc.s    V_22
+    IL_03fb:  ldloc.s    V_22
+    IL_03fd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_0402:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0407:  ldloc.s    V_22
+    IL_0409:  newobj     instance void assembly/orders4@111::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_040e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Customer,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0413:  ldsfld     class assembly/'orders4@112-1' assembly/'orders4@112-1'::@_instance
+    IL_0418:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_041d:  ldloc.s    V_22
+    IL_041f:  newobj     instance void assembly/'orders4@111-2'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0424:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0429:  ldsfld     class assembly/'orders4@114-4' assembly/'orders4@114-4'::@_instance
+    IL_042e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0433:  ldsfld     class assembly/'orders4@115-5' assembly/'orders4@115-5'::@_instance
+    IL_0438:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,int32>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_043d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,int32>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0442:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> assembly::orders4@109
+    IL_0447:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numsPlusOne()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numsPlusOne()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<string>
+          productNames()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::get_productNames()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          strings()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          textNums()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_textNums()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property class [runtime]System.Tuple`2<string,string>[]
+          upperLowerWords()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,string>[] assembly::get_upperLowerWords()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>>
+          digitOddEvens()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> assembly::get_digitOddEvens()
+  } 
+  .property class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[]
+          productInfos()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] assembly::get_productInfos()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          digits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          lowNums()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_lowNums()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbersA()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbersA()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbersB()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbersB()
+  } 
+  .property class [runtime]System.Tuple`2<int32,int32>[]
+          pairs()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<int32,int32>[] assembly::get_pairs()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[]
+          orders()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] assembly::get_orders()
+  } 
+  .property class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[]
+          orders2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::get_orders2()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>
+          orders3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> assembly::get_orders3()
+  } 
+  .property valuetype [runtime]System.DateTime
+          cutOffDate()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get valuetype [runtime]System.DateTime assembly::get_cutOffDate()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>>
+          orders4()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> assembly::get_orders4()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOn.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
new file mode 100644
index 00000000000..9455d7f1589
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
@@ -0,0 +1,3852 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 11@12-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 11@12-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<int32> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<int32>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 11@12-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 11@12-1' assembly/'Pipe #1 input at line 11@12-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 11@13'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0073
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0066
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0094
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'Pipe #1 input at line 11@12-1' assembly/'Pipe #1 input at line 11@12-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                               class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0046:  br.s       IL_0066
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  ldc.i4.1
+      IL_005e:  add
+      IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+      IL_0064:  ldc.i4.1
+      IL_0065:  ret
+
+      IL_0066:  ldarg.0
+      IL_0067:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_006c:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0071:  brtrue.s   IL_0048
+
+      IL_0073:  ldarg.0
+      IL_0074:  ldc.i4.3
+      IL_0075:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_007a:  ldarg.0
+      IL_007b:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_0080:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_0085:  nop
+      IL_0086:  ldarg.0
+      IL_0087:  ldnull
+      IL_0088:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_008d:  ldarg.0
+      IL_008e:  ldc.i4.3
+      IL_008f:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0094:  ldarg.0
+      IL_0095:  ldc.i4.0
+      IL_0096:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+      IL_009b:  ldc.i4.0
+      IL_009c:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 11@13'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                              int32,
+                                                                                              int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'productNames@21-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'productNames@21-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Product>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'productNames@21-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'productNames@21-1' assembly/'productNames@21-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname productNames@22
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/productNames@22::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/productNames@22::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productNames@22::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0076
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0069
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0097
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'productNames@21-1' assembly/'productNames@21-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                              class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/productNames@22::pc
+      IL_0046:  br.s       IL_0069
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/productNames@22::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0062:  stfld      string assembly/productNames@22::current
+      IL_0067:  ldc.i4.1
+      IL_0068:  ret
+
+      IL_0069:  ldarg.0
+      IL_006a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_006f:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0074:  brtrue.s   IL_0048
+
+      IL_0076:  ldarg.0
+      IL_0077:  ldc.i4.3
+      IL_0078:  stfld      int32 assembly/productNames@22::pc
+      IL_007d:  ldarg.0
+      IL_007e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_0083:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_0088:  nop
+      IL_0089:  ldarg.0
+      IL_008a:  ldnull
+      IL_008b:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_0090:  ldarg.0
+      IL_0091:  ldc.i4.3
+      IL_0092:  stfld      int32 assembly/productNames@22::pc
+      IL_0097:  ldarg.0
+      IL_0098:  ldnull
+      IL_0099:  stfld      string assembly/productNames@22::current
+      IL_009e:  ldc.i4.0
+      IL_009f:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productNames@22::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/productNames@22::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/productNames@22::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/productNames@22::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/productNames@22::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productNames@22::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/productNames@22::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/productNames@22::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                int32,
+                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 28@29-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 28@29-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<int32> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<int32>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 28@29-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 28@29-1' assembly/'Pipe #2 input at line 28@29-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #2 input at line 28@30'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #2 input at line 28@30'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_007b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_006e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_009c
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'Pipe #2 input at line 28@29-1' assembly/'Pipe #2 input at line 28@29-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                               class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0046:  br.s       IL_006e
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_005b:  ldarg.0
+      IL_005c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+      IL_0061:  ldloc.0
+      IL_0062:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Item(int32)
+      IL_0067:  stfld      string assembly/'Pipe #2 input at line 28@30'::current
+      IL_006c:  ldc.i4.1
+      IL_006d:  ret
+
+      IL_006e:  ldarg.0
+      IL_006f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_0074:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0079:  brtrue.s   IL_0048
+
+      IL_007b:  ldarg.0
+      IL_007c:  ldc.i4.3
+      IL_007d:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0082:  ldarg.0
+      IL_0083:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_0088:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_008d:  nop
+      IL_008e:  ldarg.0
+      IL_008f:  ldnull
+      IL_0090:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_0095:  ldarg.0
+      IL_0096:  ldc.i4.3
+      IL_0097:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_009c:  ldarg.0
+      IL_009d:  ldnull
+      IL_009e:  stfld      string assembly/'Pipe #2 input at line 28@30'::current
+      IL_00a3:  ldc.i4.0
+      IL_00a4:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #2 input at line 28@30'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #2 input at line 28@30'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #2 input at line 28@30'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                              int32,
+                                                                                              string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 37@38-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 37@38-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<string> Invoke(string _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (string V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<string>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 37@38-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 37@38-1' assembly/'Pipe #3 input at line 37@38-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #3 input at line 37@39'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<string,string>>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Tuple`2<string,string> current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 class [runtime]System.Tuple`2<string,string> current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<string,string>>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (string V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0027
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0084
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0077
+
+      IL_0021:  nop
+      IL_0022:  br         IL_00a5
+
+      IL_0027:  nop
+      IL_0028:  ldarg.0
+      IL_0029:  ldsfld     class assembly/'Pipe #3 input at line 37@38-1' assembly/'Pipe #3 input at line 37@38-1'::@_instance
+      IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_0033:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>,string>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                  class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0038:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_003d:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_0042:  ldarg.0
+      IL_0043:  ldc.i4.1
+      IL_0044:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_0049:  br.s       IL_0077
+
+      IL_004b:  ldarg.0
+      IL_004c:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_0051:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_0056:  stloc.0
+      IL_0057:  ldarg.0
+      IL_0058:  ldc.i4.2
+      IL_0059:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_005e:  ldarg.0
+      IL_005f:  ldloc.0
+      IL_0060:  callvirt   instance string [runtime]System.String::ToUpper()
+      IL_0065:  ldloc.0
+      IL_0066:  callvirt   instance string [runtime]System.String::ToLower()
+      IL_006b:  newobj     instance void class [runtime]System.Tuple`2<string,string>::.ctor(!0,
+                                                                                                    !1)
+      IL_0070:  stfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+      IL_0075:  ldc.i4.1
+      IL_0076:  ret
+
+      IL_0077:  ldarg.0
+      IL_0078:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_007d:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0082:  brtrue.s   IL_004b
+
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_0091:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_0096:  nop
+      IL_0097:  ldarg.0
+      IL_0098:  ldnull
+      IL_0099:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_009e:  ldarg.0
+      IL_009f:  ldc.i4.3
+      IL_00a0:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_00a5:  ldarg.0
+      IL_00a6:  ldnull
+      IL_00a7:  stfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+      IL_00ac:  ldc.i4.0
+      IL_00ad:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,string> get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<string,string>> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #3 input at line 37@39'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                              int32,
+                                                                                              class [runtime]System.Tuple`2<string,string>)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 44@45-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 44@45-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<int32> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<int32>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 44@45-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 44@45-1' assembly/'Pipe #4 input at line 44@45-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #4 input at line 44@46'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<string,bool>>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Tuple`2<string,bool> current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 class [runtime]System.Tuple`2<string,bool> current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<string,bool>>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,bool>>& next) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0027
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0089
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_007c
+
+      IL_0021:  nop
+      IL_0022:  br         IL_00aa
+
+      IL_0027:  nop
+      IL_0028:  ldarg.0
+      IL_0029:  ldsfld     class assembly/'Pipe #4 input at line 44@45-1' assembly/'Pipe #4 input at line 44@45-1'::@_instance
+      IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_0033:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                               class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0038:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_003d:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0042:  ldarg.0
+      IL_0043:  ldc.i4.1
+      IL_0044:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0049:  br.s       IL_007c
+
+      IL_004b:  ldarg.0
+      IL_004c:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0051:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0056:  stloc.0
+      IL_0057:  ldarg.0
+      IL_0058:  ldc.i4.2
+      IL_0059:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_005e:  ldarg.0
+      IL_005f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+      IL_0064:  ldloc.0
+      IL_0065:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Item(int32)
+      IL_006a:  ldloc.0
+      IL_006b:  ldc.i4.2
+      IL_006c:  rem
+      IL_006d:  ldc.i4.0
+      IL_006e:  ceq
+      IL_0070:  newobj     instance void class [runtime]System.Tuple`2<string,bool>::.ctor(!0,
+                                                                                                  !1)
+      IL_0075:  stfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+      IL_007a:  ldc.i4.1
+      IL_007b:  ret
+
+      IL_007c:  ldarg.0
+      IL_007d:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0082:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0087:  brtrue.s   IL_004b
+
+      IL_0089:  ldarg.0
+      IL_008a:  ldc.i4.3
+      IL_008b:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0090:  ldarg.0
+      IL_0091:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0096:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_009b:  nop
+      IL_009c:  ldarg.0
+      IL_009d:  ldnull
+      IL_009e:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_00a3:  ldarg.0
+      IL_00a4:  ldc.i4.3
+      IL_00a5:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_00aa:  ldarg.0
+      IL_00ab:  ldnull
+      IL_00ac:  stfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+      IL_00b1:  ldc.i4.0
+      IL_00b2:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,bool> get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<string,bool>> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #4 input at line 44@46'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                              int32,
+                                                                                              class [runtime]System.Tuple`2<string,bool>)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 51@52-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 51@52-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Product>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 51@52-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 51@52-1' assembly/'Pipe #5 input at line 51@52-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #5 input at line 51@53'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>>& next) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0027
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_008a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_007d
+
+      IL_0021:  nop
+      IL_0022:  br         IL_00ab
+
+      IL_0027:  nop
+      IL_0028:  ldarg.0
+      IL_0029:  ldsfld     class assembly/'Pipe #5 input at line 51@52-1' assembly/'Pipe #5 input at line 51@52-1'::@_instance
+      IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_0033:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                              class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0038:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_003d:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0042:  ldarg.0
+      IL_0043:  ldc.i4.1
+      IL_0044:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0049:  br.s       IL_007d
+
+      IL_004b:  ldarg.0
+      IL_004c:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0051:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_0056:  stloc.0
+      IL_0057:  ldarg.0
+      IL_0058:  ldc.i4.2
+      IL_0059:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_005e:  ldarg.0
+      IL_005f:  ldloc.0
+      IL_0060:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0065:  ldloc.0
+      IL_0066:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_006b:  ldloc.0
+      IL_006c:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0071:  newobj     instance void class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                             !1,
+                                                                                                                                             !2)
+      IL_0076:  stfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+      IL_007b:  ldc.i4.1
+      IL_007c:  ret
+
+      IL_007d:  ldarg.0
+      IL_007e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0083:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0088:  brtrue.s   IL_004b
+
+      IL_008a:  ldarg.0
+      IL_008b:  ldc.i4.3
+      IL_008c:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0091:  ldarg.0
+      IL_0092:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0097:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_009c:  nop
+      IL_009d:  ldarg.0
+      IL_009e:  ldnull
+      IL_009f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_00a4:  ldarg.0
+      IL_00a5:  ldc.i4.3
+      IL_00a6:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_00ab:  ldarg.0
+      IL_00ac:  ldnull
+      IL_00ad:  stfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+      IL_00b2:  ldc.i4.0
+      IL_00b3:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #5 input at line 51@53'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                              int32,
+                                                                                              class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@60'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 59@60'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 59@60'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<int32,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@61-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@61-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.5
+      IL_0002:  clt
+      IL_0004:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@61-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@61-1' assembly/'Pipe #6 input at line 59@61-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@62-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@62-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+      IL_0005:  ldarg.1
+      IL_0006:  tail.
+      IL_0008:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Item(int32)
+      IL_000d:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@62-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@62-2' assembly/'Pipe #6 input at line 59@62-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 71@73-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 a
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 int32 a) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@73-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      int32 assembly/'Pipe #7 input at line 71@73-1'::a
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,object> Invoke(int32 _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@73-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      int32 assembly/'Pipe #7 input at line 71@73-1'::a
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<int32,int32>::.ctor(!0,
+                                                                                                  !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<int32,int32>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 71@72'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@72'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@72'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@72'::builder@
+      IL_000e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbersB()
+      IL_0013:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0018:  ldarg.0
+      IL_0019:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@72'::builder@
+      IL_001e:  ldloc.0
+      IL_001f:  newobj     instance void assembly/'Pipe #7 input at line 71@73-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                int32)
+      IL_0024:  tail.
+      IL_0026:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,int32>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 71@74-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<int32,int32>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 71@74-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<int32,int32>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<int32,int32> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<int32,int32>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<int32,int32>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  clt
+      IL_0012:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 71@74-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 71@74-2' assembly/'Pipe #7 input at line 71@74-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 71@75-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Tuple`2<int32,int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 71@75-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Tuple`2<int32,int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,int32> Invoke(class [runtime]System.Tuple`2<int32,int32> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<int32,int32>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<int32,int32>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  newobj     instance void class [runtime]System.Tuple`2<int32,int32>::.ctor(!0,
+                                                                                                  !1)
+      IL_0015:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 71@75-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 71@75-3' assembly/'Pipe #7 input at line 71@75-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #8 input at line 81@83-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@83-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'Pipe #8 input at line 81@83-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@83-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'Pipe #8 input at line 81@83-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                           !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #8 input at line 81@82'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@82'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@82'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@82'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@82'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'Pipe #8 input at line 81@83-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #8 input at line 81@84-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #8 input at line 81@84-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Order::get_Total()
+      IL_0014:  ldc.i4     0xc350
+      IL_0019:  ldc.i4.0
+      IL_001a:  ldc.i4.0
+      IL_001b:  ldc.i4.0
+      IL_001c:  ldc.i4.2
+      IL_001d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                            int32,
+                                                                            int32,
+                                                                            bool,
+                                                                            uint8)
+      IL_0022:  call       bool [netstandard]System.Decimal::op_LessThan(valuetype [netstandard]System.Decimal,
+                                                                         valuetype [netstandard]System.Decimal)
+      IL_0027:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #8 input at line 81@84-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #8 input at line 81@84-2' assembly/'Pipe #8 input at line 81@84-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #8 input at line 81@85-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'Pipe #8 input at line 81@85-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Order::get_Total()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                            !1,
+                                                                                                                                            !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #8 input at line 81@85-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #8 input at line 81@85-3' assembly/'Pipe #8 input at line 81@85-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #9 input at line 90@92-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@92-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'Pipe #9 input at line 90@92-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@92-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'Pipe #9 input at line 90@92-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                           !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #9 input at line 90@91'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@91'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@91'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@91'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@91'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'Pipe #9 input at line 90@92-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #9 input at line 90@93-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #9 input at line 90@93-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1,
+               valuetype [runtime]System.DateTime V_2,
+               valuetype [runtime]System.DateTime V_3,
+               valuetype [runtime]System.DateTime V_4,
+               valuetype [runtime]System.DateTime V_5,
+               valuetype [runtime]System.DateTime V_6,
+               valuetype [runtime]System.DateTime V_7)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0014:  stloc.2
+      IL_0015:  ldc.i4     0x7ce
+      IL_001a:  ldc.i4.1
+      IL_001b:  ldc.i4.1
+      IL_001c:  newobj     instance void [runtime]System.DateTime::.ctor(int32,
+                                                                                int32,
+                                                                                int32)
+      IL_0021:  stloc.3
+      IL_0022:  ldloc.2
+      IL_0023:  stloc.s    V_4
+      IL_0025:  ldloc.3
+      IL_0026:  stloc.s    V_5
+      IL_0028:  ldloc.s    V_4
+      IL_002a:  stloc.s    V_6
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  stloc.s    V_7
+      IL_0030:  ldloc.s    V_6
+      IL_0032:  ldloc.s    V_7
+      IL_0034:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_0039:  ldc.i4.0
+      IL_003a:  clt
+      IL_003c:  ldc.i4.0
+      IL_003d:  ceq
+      IL_003f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #9 input at line 90@93-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #9 input at line 90@93-2' assembly/'Pipe #9 input at line 90@93-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #9 input at line 90@94-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>
+  {
+    .field static assembly initonly class assembly/'Pipe #9 input at line 90@94-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>::.ctor(!0,
+                                                                                                                                             !1,
+                                                                                                                                             !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #9 input at line 90@94-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #9 input at line 90@94-3' assembly/'Pipe #9 input at line 90@94-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders3@101-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders3@101-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'orders3@101-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders3@101-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'orders3@101-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                           !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit orders3@100
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders3@100::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders3@100::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders3@100::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders3@100::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'orders3@101-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders3@102-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'orders3@102-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Order::get_Total()
+      IL_0014:  ldc.i4     0x4e20
+      IL_0019:  ldc.i4.0
+      IL_001a:  ldc.i4.0
+      IL_001b:  ldc.i4.0
+      IL_001c:  ldc.i4.1
+      IL_001d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                            int32,
+                                                                            int32,
+                                                                            bool,
+                                                                            uint8)
+      IL_0022:  call       bool [netstandard]System.Decimal::op_GreaterThanOrEqual(valuetype [netstandard]System.Decimal,
+                                                                                   valuetype [netstandard]System.Decimal)
+      IL_0027:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders3@102-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders3@102-2' assembly/'orders3@102-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders3@103-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'orders3@103-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Order::get_Total()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                            !1,
+                                                                                                                                            !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders3@103-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders3@103-3' assembly/'orders3@103-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit orders4@111
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders4@111::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders4@111::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Customer,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@112-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,bool>
+  {
+    .field static assembly initonly class assembly/'orders4@112-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Customer c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance string [Utils]Utils/Customer::get_Region()
+      IL_0006:  ldstr      "WA"
+      IL_000b:  call       bool [netstandard]System.String::Equals(string,
+                                                                   string)
+      IL_0010:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders4@112-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders4@112-1' assembly/'orders4@112-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@113-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@113-3'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'orders4@113-3'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg3) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@113-3'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'orders4@113-3'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                           !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@111-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@111-2'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg2) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@111-2'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@111-2'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@111-2'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'orders4@113-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@114-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'orders4@114-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1,
+               valuetype [runtime]System.DateTime V_2,
+               valuetype [runtime]System.DateTime V_3,
+               valuetype [runtime]System.DateTime V_4,
+               valuetype [runtime]System.DateTime V_5,
+               valuetype [runtime]System.DateTime V_6,
+               valuetype [runtime]System.DateTime V_7)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0014:  stloc.2
+      IL_0015:  call       valuetype [runtime]System.DateTime assembly::get_cutOffDate()
+      IL_001a:  stloc.3
+      IL_001b:  ldloc.2
+      IL_001c:  stloc.s    V_4
+      IL_001e:  ldloc.3
+      IL_001f:  stloc.s    V_5
+      IL_0021:  ldloc.s    V_4
+      IL_0023:  stloc.s    V_6
+      IL_0025:  ldloc.s    V_5
+      IL_0027:  stloc.s    V_7
+      IL_0029:  ldloc.s    V_6
+      IL_002b:  ldloc.s    V_7
+      IL_002d:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_0032:  ldc.i4.0
+      IL_0033:  clt
+      IL_0035:  ldc.i4.0
+      IL_0036:  ceq
+      IL_0038:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders4@114-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders4@114-4' assembly/'orders4@114-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@115-5'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`2<string,int32>>
+  {
+    .field static assembly initonly class assembly/'orders4@115-5' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`2<string,int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,int32> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  newobj     instance void class [runtime]System.Tuple`2<string,int32>::.ctor(!0,
+                                                                                                   !1)
+      IL_001f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders4@115-5'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders4@115-5' assembly/'orders4@115-5'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numsPlusOne@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<string> productNames@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> strings@26
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> textNums@27
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@34
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,string>[] upperLowerWords@36
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> digitOddEvens@43
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] productInfos@50
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> digits@57
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> lowNums@58
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbersA@67
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbersB@68
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<int32,int32>[] pairs@70
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@79
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] orders@80
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] orders2@89
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> orders3@98
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly valuetype [runtime]System.DateTime cutOffDate@107
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> orders4@109
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@7
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numsPlusOne() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numsPlusOne@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@17
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<string> get_productNames() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::productNames@19
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_strings() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::strings@26
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_textNums() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::textNums@27
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@34
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,string>[] get_upperLowerWords() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,string>[] assembly::upperLowerWords@36
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> get_digitOddEvens() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> assembly::digitOddEvens@43
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] get_productInfos() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] assembly::productInfos@50
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_digits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@57
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_lowNums() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::lowNums@58
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbersA() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbersA@67
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbersB() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbersB@68
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<int32,int32>[] get_pairs() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<int32,int32>[] assembly::pairs@70
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@79
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] get_orders() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] assembly::orders@80
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] get_orders2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::orders2@89
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> get_orders3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> assembly::orders3@98
+    IL_0005:  ret
+  } 
+
+  .method public specialname static valuetype [runtime]System.DateTime get_cutOffDate() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     valuetype [runtime]System.DateTime assembly::cutOffDate@107
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> get_orders4() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> assembly::orders4@109
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_3,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_4,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>> V_5,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_6,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,bool>> V_7,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_8,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>> V_9,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_10,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_11,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_12,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> V_13,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> V_14,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> V_15,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> V_16,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> V_17,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> V_18,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,int32>> V_19,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_20,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> V_21,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_22,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> V_23,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_24,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_25,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_26)
+    IL_0000:  ldc.i4.5
+    IL_0001:  ldc.i4.4
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.3
+    IL_0004:  ldc.i4.s   9
+    IL_0006:  ldc.i4.8
+    IL_0007:  ldc.i4.6
+    IL_0008:  ldc.i4.7
+    IL_0009:  ldc.i4.2
+    IL_000a:  ldc.i4.0
+    IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0010:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0015:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0024:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0029:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0033:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_003d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0042:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@7
+    IL_0047:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_004c:  stloc.1
+    IL_004d:  ldnull
+    IL_004e:  ldc.i4.0
+    IL_004f:  ldc.i4.0
+    IL_0050:  newobj     instance void assembly/'Pipe #1 input at line 11@13'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                            int32,
+                                                                                            int32)
+    IL_0055:  stloc.0
+    IL_0056:  ldloc.0
+    IL_0057:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_005c:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numsPlusOne@10
+    IL_0061:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0066:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@17
+    IL_006b:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0070:  stloc.2
+    IL_0071:  ldnull
+    IL_0072:  ldc.i4.0
+    IL_0073:  ldnull
+    IL_0074:  newobj     instance void assembly/productNames@22::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                              int32,
+                                                                              string)
+    IL_0079:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::productNames@19
+    IL_007e:  ldstr      "zero"
+    IL_0083:  ldstr      "one"
+    IL_0088:  ldstr      "two"
+    IL_008d:  ldstr      "three"
+    IL_0092:  ldstr      "four"
+    IL_0097:  ldstr      "five"
+    IL_009c:  ldstr      "six"
+    IL_00a1:  ldstr      "seven"
+    IL_00a6:  ldstr      "eight"
+    IL_00ab:  ldstr      "nine"
+    IL_00b0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_00b5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00ba:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00bf:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00c4:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00c9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00ce:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00d3:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00d8:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00dd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00e2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00e7:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::strings@26
+    IL_00ec:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00f1:  stloc.s    V_4
+    IL_00f3:  ldnull
+    IL_00f4:  ldc.i4.0
+    IL_00f5:  ldnull
+    IL_00f6:  newobj     instance void assembly/'Pipe #2 input at line 28@30'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                            int32,
+                                                                                            string)
+    IL_00fb:  stloc.3
+    IL_00fc:  ldloc.3
+    IL_00fd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0102:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::textNums@27
+    IL_0107:  ldstr      "aPPLE"
+    IL_010c:  ldstr      "BlUeBeRrY"
+    IL_0111:  ldstr      "cHeRry"
+    IL_0116:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_011b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0120:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0125:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_012a:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@34
+    IL_012f:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0134:  stloc.s    V_6
+    IL_0136:  ldnull
+    IL_0137:  ldc.i4.0
+    IL_0138:  ldnull
+    IL_0139:  newobj     instance void assembly/'Pipe #3 input at line 37@39'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                            int32,
+                                                                                            class [runtime]System.Tuple`2<string,string>)
+    IL_013e:  stloc.s    V_5
+    IL_0140:  ldloc.s    V_5
+    IL_0142:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,string>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0147:  stsfld     class [runtime]System.Tuple`2<string,string>[] assembly::upperLowerWords@36
+    IL_014c:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0151:  stloc.s    V_8
+    IL_0153:  ldnull
+    IL_0154:  ldc.i4.0
+    IL_0155:  ldnull
+    IL_0156:  newobj     instance void assembly/'Pipe #4 input at line 44@46'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                            int32,
+                                                                                            class [runtime]System.Tuple`2<string,bool>)
+    IL_015b:  stloc.s    V_7
+    IL_015d:  ldloc.s    V_7
+    IL_015f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<class [runtime]System.Tuple`2<string,bool>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0164:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> assembly::digitOddEvens@43
+    IL_0169:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_016e:  stloc.s    V_10
+    IL_0170:  ldnull
+    IL_0171:  ldc.i4.0
+    IL_0172:  ldnull
+    IL_0173:  newobj     instance void assembly/'Pipe #5 input at line 51@53'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                            int32,
+                                                                                            class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>)
+    IL_0178:  stloc.s    V_9
+    IL_017a:  ldloc.s    V_9
+    IL_017c:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0181:  stsfld     class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] assembly::productInfos@50
+    IL_0186:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+    IL_018b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@57
+    IL_0190:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0195:  stloc.s    V_12
+    IL_0197:  ldloc.s    V_12
+    IL_0199:  ldloc.s    V_12
+    IL_019b:  ldloc.s    V_12
+    IL_019d:  ldloc.s    V_12
+    IL_019f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+    IL_01a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01a9:  ldloc.s    V_12
+    IL_01ab:  newobj     instance void assembly/'Pipe #6 input at line 59@60'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01b0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,int32,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01b5:  ldsfld     class assembly/'Pipe #6 input at line 59@61-1' assembly/'Pipe #6 input at line 59@61-1'::@_instance
+    IL_01ba:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_01bf:  ldsfld     class assembly/'Pipe #6 input at line 59@62-2' assembly/'Pipe #6 input at line 59@62-2'::@_instance
+    IL_01c4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<int32,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01c9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_01ce:  stloc.s    V_11
+    IL_01d0:  ldloc.s    V_11
+    IL_01d2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01d7:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::lowNums@58
+    IL_01dc:  nop
+    IL_01dd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_lowNums()
+    IL_01e2:  stloc.s    V_13
+    IL_01e4:  ldstr      "four"
+    IL_01e9:  ldstr      "one"
+    IL_01ee:  ldstr      "three"
+    IL_01f3:  ldstr      "two"
+    IL_01f8:  ldstr      "zero"
+    IL_01fd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0202:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0207:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_020c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0211:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0216:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_021b:  stloc.s    V_14
+    IL_021d:  ldloc.s    V_13
+    IL_021f:  stloc.s    V_15
+    IL_0221:  ldloc.s    V_14
+    IL_0223:  stloc.s    V_16
+    IL_0225:  ldloc.s    V_15
+    IL_0227:  stloc.s    V_17
+    IL_0229:  ldloc.s    V_16
+    IL_022b:  stloc.s    V_18
+    IL_022d:  ldloc.s    V_17
+    IL_022f:  ldloc.s    V_18
+    IL_0231:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0236:  callvirt   instance bool class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Equals(object,
+                                                                                                                    class [runtime]System.Collections.IEqualityComparer)
+    IL_023b:  ldc.i4.0
+    IL_023c:  ceq
+    IL_023e:  brfalse.s  IL_025a
+
+    IL_0240:  ldstr      "lowNums failed"
+    IL_0245:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_024a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_024f:  pop
+    IL_0250:  ldc.i4.1
+    IL_0251:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_0256:  pop
+    IL_0257:  nop
+    IL_0258:  br.s       IL_025b
+
+    IL_025a:  nop
+    IL_025b:  ldc.i4.0
+    IL_025c:  ldc.i4.2
+    IL_025d:  ldc.i4.4
+    IL_025e:  ldc.i4.5
+    IL_025f:  ldc.i4.6
+    IL_0260:  ldc.i4.8
+    IL_0261:  ldc.i4.s   9
+    IL_0263:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0268:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_026d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0272:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0277:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_027c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0281:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0286:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_028b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbersA@67
+    IL_0290:  ldc.i4.1
+    IL_0291:  ldc.i4.3
+    IL_0292:  ldc.i4.5
+    IL_0293:  ldc.i4.7
+    IL_0294:  ldc.i4.8
+    IL_0295:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_029a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_029f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_02a4:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_02a9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_02ae:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_02b3:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbersB@68
+    IL_02b8:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_02bd:  stloc.s    V_20
+    IL_02bf:  ldloc.s    V_20
+    IL_02c1:  ldloc.s    V_20
+    IL_02c3:  ldloc.s    V_20
+    IL_02c5:  ldloc.s    V_20
+    IL_02c7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbersA()
+    IL_02cc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_02d1:  ldloc.s    V_20
+    IL_02d3:  newobj     instance void assembly/'Pipe #7 input at line 71@72'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_02d8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_02dd:  ldsfld     class assembly/'Pipe #7 input at line 71@74-2' assembly/'Pipe #7 input at line 71@74-2'::@_instance
+    IL_02e2:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_02e7:  ldsfld     class assembly/'Pipe #7 input at line 71@75-3' assembly/'Pipe #7 input at line 71@75-3'::@_instance
+    IL_02ec:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,int32>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_02f1:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_02f6:  stloc.s    V_19
+    IL_02f8:  ldloc.s    V_19
+    IL_02fa:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<int32,int32>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_02ff:  stsfld     class [runtime]System.Tuple`2<int32,int32>[] assembly::pairs@70
+    IL_0304:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_0309:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@79
+    IL_030e:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0313:  stloc.s    V_22
+    IL_0315:  ldloc.s    V_22
+    IL_0317:  ldloc.s    V_22
+    IL_0319:  ldloc.s    V_22
+    IL_031b:  ldloc.s    V_22
+    IL_031d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_0322:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0327:  ldloc.s    V_22
+    IL_0329:  newobj     instance void assembly/'Pipe #8 input at line 81@82'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_032e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0333:  ldsfld     class assembly/'Pipe #8 input at line 81@84-2' assembly/'Pipe #8 input at line 81@84-2'::@_instance
+    IL_0338:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_033d:  ldsfld     class assembly/'Pipe #8 input at line 81@85-3' assembly/'Pipe #8 input at line 81@85-3'::@_instance
+    IL_0342:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0347:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_034c:  stloc.s    V_21
+    IL_034e:  ldloc.s    V_21
+    IL_0350:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0355:  stsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] assembly::orders@80
+    IL_035a:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_035f:  stloc.s    V_24
+    IL_0361:  ldloc.s    V_24
+    IL_0363:  ldloc.s    V_24
+    IL_0365:  ldloc.s    V_24
+    IL_0367:  ldloc.s    V_24
+    IL_0369:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_036e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0373:  ldloc.s    V_24
+    IL_0375:  newobj     instance void assembly/'Pipe #9 input at line 90@91'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_037a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_037f:  ldsfld     class assembly/'Pipe #9 input at line 90@93-2' assembly/'Pipe #9 input at line 90@93-2'::@_instance
+    IL_0384:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0389:  ldsfld     class assembly/'Pipe #9 input at line 90@94-3' assembly/'Pipe #9 input at line 90@94-3'::@_instance
+    IL_038e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0393:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0398:  stloc.s    V_23
+    IL_039a:  ldloc.s    V_23
+    IL_039c:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_03a1:  stsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::orders2@89
+    IL_03a6:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_03ab:  stloc.s    V_25
+    IL_03ad:  ldloc.s    V_25
+    IL_03af:  ldloc.s    V_25
+    IL_03b1:  ldloc.s    V_25
+    IL_03b3:  ldloc.s    V_25
+    IL_03b5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_03ba:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_03bf:  ldloc.s    V_25
+    IL_03c1:  newobj     instance void assembly/orders3@100::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_03c6:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_03cb:  ldsfld     class assembly/'orders3@102-2' assembly/'orders3@102-2'::@_instance
+    IL_03d0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_03d5:  ldsfld     class assembly/'orders3@103-3' assembly/'orders3@103-3'::@_instance
+    IL_03da:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_03df:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_03e4:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> assembly::orders3@98
+    IL_03e9:  ldc.i4     0x7cd
+    IL_03ee:  ldc.i4.1
+    IL_03ef:  ldc.i4.1
+    IL_03f0:  newobj     instance void [runtime]System.DateTime::.ctor(int32,
+                                                                              int32,
+                                                                              int32)
+    IL_03f5:  stsfld     valuetype [runtime]System.DateTime assembly::cutOffDate@107
+    IL_03fa:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_03ff:  stloc.s    V_26
+    IL_0401:  ldloc.s    V_26
+    IL_0403:  ldloc.s    V_26
+    IL_0405:  ldloc.s    V_26
+    IL_0407:  ldloc.s    V_26
+    IL_0409:  ldloc.s    V_26
+    IL_040b:  ldloc.s    V_26
+    IL_040d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_0412:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0417:  ldloc.s    V_26
+    IL_0419:  newobj     instance void assembly/orders4@111::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_041e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Customer,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0423:  ldsfld     class assembly/'orders4@112-1' assembly/'orders4@112-1'::@_instance
+    IL_0428:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_042d:  ldloc.s    V_26
+    IL_042f:  newobj     instance void assembly/'orders4@111-2'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0434:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0439:  ldsfld     class assembly/'orders4@114-4' assembly/'orders4@114-4'::@_instance
+    IL_043e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0443:  ldsfld     class assembly/'orders4@115-5' assembly/'orders4@115-5'::@_instance
+    IL_0448:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,int32>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_044d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,int32>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0452:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> assembly::orders4@109
+    IL_0457:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numsPlusOne()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numsPlusOne()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<string>
+          productNames()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::get_productNames()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          strings()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          textNums()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_textNums()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property class [runtime]System.Tuple`2<string,string>[]
+          upperLowerWords()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,string>[] assembly::get_upperLowerWords()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>>
+          digitOddEvens()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> assembly::get_digitOddEvens()
+  } 
+  .property class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[]
+          productInfos()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] assembly::get_productInfos()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          digits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          lowNums()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_lowNums()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbersA()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbersA()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbersB()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbersB()
+  } 
+  .property class [runtime]System.Tuple`2<int32,int32>[]
+          pairs()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<int32,int32>[] assembly::get_pairs()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[]
+          orders()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] assembly::get_orders()
+  } 
+  .property class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[]
+          orders2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::get_orders2()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>
+          orders3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> assembly::get_orders3()
+  } 
+  .property valuetype [runtime]System.DateTime
+          cutOffDate()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get valuetype [runtime]System.DateTime assembly::get_cutOffDate()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>>
+          orders4()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> assembly::get_orders4()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOn.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOn.il.netcore.release.bsl
new file mode 100644
index 00000000000..00e57c54bd9
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Select01.fs.RealInternalSignatureOn.il.netcore.release.bsl
@@ -0,0 +1,3816 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 11@12-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 11@12-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<int32> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<int32>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 11@12-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 11@12-1' assembly/'Pipe #1 input at line 11@12-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 11@13'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0073
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0066
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0094
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'Pipe #1 input at line 11@12-1' assembly/'Pipe #1 input at line 11@12-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                               class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0046:  br.s       IL_0066
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  ldc.i4.1
+      IL_005e:  add
+      IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+      IL_0064:  ldc.i4.1
+      IL_0065:  ret
+
+      IL_0066:  ldarg.0
+      IL_0067:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_006c:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0071:  brtrue.s   IL_0048
+
+      IL_0073:  ldarg.0
+      IL_0074:  ldc.i4.3
+      IL_0075:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_007a:  ldarg.0
+      IL_007b:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_0080:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_0085:  nop
+      IL_0086:  ldarg.0
+      IL_0087:  ldnull
+      IL_0088:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+      IL_008d:  ldarg.0
+      IL_008e:  ldc.i4.3
+      IL_008f:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0094:  ldarg.0
+      IL_0095:  ldc.i4.0
+      IL_0096:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+      IL_009b:  ldc.i4.0
+      IL_009c:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 11@13'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 11@13'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 11@13'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                              int32,
+                                                                                              int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'productNames@21-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'productNames@21-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Product>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'productNames@21-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'productNames@21-1' assembly/'productNames@21-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname productNames@22
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/productNames@22::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/productNames@22::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productNames@22::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0076
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0069
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0097
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'productNames@21-1' assembly/'productNames@21-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                              class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/productNames@22::pc
+      IL_0046:  br.s       IL_0069
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/productNames@22::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0062:  stfld      string assembly/productNames@22::current
+      IL_0067:  ldc.i4.1
+      IL_0068:  ret
+
+      IL_0069:  ldarg.0
+      IL_006a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_006f:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0074:  brtrue.s   IL_0048
+
+      IL_0076:  ldarg.0
+      IL_0077:  ldc.i4.3
+      IL_0078:  stfld      int32 assembly/productNames@22::pc
+      IL_007d:  ldarg.0
+      IL_007e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_0083:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_0088:  nop
+      IL_0089:  ldarg.0
+      IL_008a:  ldnull
+      IL_008b:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+      IL_0090:  ldarg.0
+      IL_0091:  ldc.i4.3
+      IL_0092:  stfld      int32 assembly/productNames@22::pc
+      IL_0097:  ldarg.0
+      IL_0098:  ldnull
+      IL_0099:  stfld      string assembly/productNames@22::current
+      IL_009e:  ldc.i4.0
+      IL_009f:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productNames@22::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/productNames@22::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/productNames@22::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productNames@22::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/productNames@22::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/productNames@22::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productNames@22::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/productNames@22::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/productNames@22::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                int32,
+                                                                                string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 28@29-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 28@29-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<int32> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<int32>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 28@29-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 28@29-1' assembly/'Pipe #2 input at line 28@29-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #2 input at line 28@30'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #2 input at line 28@30'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_007b
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_006e
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_009c
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'Pipe #2 input at line 28@29-1' assembly/'Pipe #2 input at line 28@29-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                               class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0046:  br.s       IL_006e
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_005b:  ldarg.0
+      IL_005c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+      IL_0061:  ldloc.0
+      IL_0062:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Item(int32)
+      IL_0067:  stfld      string assembly/'Pipe #2 input at line 28@30'::current
+      IL_006c:  ldc.i4.1
+      IL_006d:  ret
+
+      IL_006e:  ldarg.0
+      IL_006f:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_0074:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0079:  brtrue.s   IL_0048
+
+      IL_007b:  ldarg.0
+      IL_007c:  ldc.i4.3
+      IL_007d:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0082:  ldarg.0
+      IL_0083:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_0088:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_008d:  nop
+      IL_008e:  ldarg.0
+      IL_008f:  ldnull
+      IL_0090:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+      IL_0095:  ldarg.0
+      IL_0096:  ldc.i4.3
+      IL_0097:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_009c:  ldarg.0
+      IL_009d:  ldnull
+      IL_009e:  stfld      string assembly/'Pipe #2 input at line 28@30'::current
+      IL_00a3:  ldc.i4.0
+      IL_00a4:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #2 input at line 28@30'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #2 input at line 28@30'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 28@30'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #2 input at line 28@30'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #2 input at line 28@30'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                              int32,
+                                                                                              string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 37@38-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 37@38-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<string> Invoke(string _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (string V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<string>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 37@38-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 37@38-1' assembly/'Pipe #3 input at line 37@38-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #3 input at line 37@39'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<string,string>>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Tuple`2<string,string> current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 class [runtime]System.Tuple`2<string,string> current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<string,string>>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (string V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0027
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0084
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0077
+
+      IL_0021:  nop
+      IL_0022:  br         IL_00a5
+
+      IL_0027:  nop
+      IL_0028:  ldarg.0
+      IL_0029:  ldsfld     class assembly/'Pipe #3 input at line 37@38-1' assembly/'Pipe #3 input at line 37@38-1'::@_instance
+      IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+      IL_0033:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>,string>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                  class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0038:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_003d:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_0042:  ldarg.0
+      IL_0043:  ldc.i4.1
+      IL_0044:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_0049:  br.s       IL_0077
+
+      IL_004b:  ldarg.0
+      IL_004c:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_0051:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_0056:  stloc.0
+      IL_0057:  ldarg.0
+      IL_0058:  ldc.i4.2
+      IL_0059:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_005e:  ldarg.0
+      IL_005f:  ldloc.0
+      IL_0060:  callvirt   instance string [runtime]System.String::ToUpper()
+      IL_0065:  ldloc.0
+      IL_0066:  callvirt   instance string [runtime]System.String::ToLower()
+      IL_006b:  newobj     instance void class [runtime]System.Tuple`2<string,string>::.ctor(!0,
+                                                                                                    !1)
+      IL_0070:  stfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+      IL_0075:  ldc.i4.1
+      IL_0076:  ret
+
+      IL_0077:  ldarg.0
+      IL_0078:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_007d:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0082:  brtrue.s   IL_004b
+
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_0091:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_0096:  nop
+      IL_0097:  ldarg.0
+      IL_0098:  ldnull
+      IL_0099:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+      IL_009e:  ldarg.0
+      IL_009f:  ldc.i4.3
+      IL_00a0:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_00a5:  ldarg.0
+      IL_00a6:  ldnull
+      IL_00a7:  stfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+      IL_00ac:  ldc.i4.0
+      IL_00ad:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 37@39'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 37@39'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,string> get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [runtime]System.Tuple`2<string,string> assembly/'Pipe #3 input at line 37@39'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<string,string>> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #3 input at line 37@39'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                              int32,
+                                                                                              class [runtime]System.Tuple`2<string,string>)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #4 input at line 44@45-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #4 input at line 44@45-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<int32> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<int32>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #4 input at line 44@45-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #4 input at line 44@45-1' assembly/'Pipe #4 input at line 44@45-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #4 input at line 44@46'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<string,bool>>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Tuple`2<string,bool> current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 class [runtime]System.Tuple`2<string,bool> current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`2<string,bool>>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,bool>>& next) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0027
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0089
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_007c
+
+      IL_0021:  nop
+      IL_0022:  br         IL_00aa
+
+      IL_0027:  nop
+      IL_0028:  ldarg.0
+      IL_0029:  ldsfld     class assembly/'Pipe #4 input at line 44@45-1' assembly/'Pipe #4 input at line 44@45-1'::@_instance
+      IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+      IL_0033:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<int32,class [runtime]System.Collections.Generic.IEnumerable`1<int32>,int32>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                               class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0038:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_003d:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0042:  ldarg.0
+      IL_0043:  ldc.i4.1
+      IL_0044:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0049:  br.s       IL_007c
+
+      IL_004b:  ldarg.0
+      IL_004c:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0051:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0056:  stloc.0
+      IL_0057:  ldarg.0
+      IL_0058:  ldc.i4.2
+      IL_0059:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_005e:  ldarg.0
+      IL_005f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+      IL_0064:  ldloc.0
+      IL_0065:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Item(int32)
+      IL_006a:  ldloc.0
+      IL_006b:  ldc.i4.2
+      IL_006c:  rem
+      IL_006d:  ldc.i4.0
+      IL_006e:  ceq
+      IL_0070:  newobj     instance void class [runtime]System.Tuple`2<string,bool>::.ctor(!0,
+                                                                                                  !1)
+      IL_0075:  stfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+      IL_007a:  ldc.i4.1
+      IL_007b:  ret
+
+      IL_007c:  ldarg.0
+      IL_007d:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0082:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0087:  brtrue.s   IL_004b
+
+      IL_0089:  ldarg.0
+      IL_008a:  ldc.i4.3
+      IL_008b:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0090:  ldarg.0
+      IL_0091:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_0096:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_009b:  nop
+      IL_009c:  ldarg.0
+      IL_009d:  ldnull
+      IL_009e:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+      IL_00a3:  ldarg.0
+      IL_00a4:  ldc.i4.3
+      IL_00a5:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_00aa:  ldarg.0
+      IL_00ab:  ldnull
+      IL_00ac:  stfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+      IL_00b1:  ldc.i4.0
+      IL_00b2:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #4 input at line 44@46'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #4 input at line 44@46'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,bool> get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [runtime]System.Tuple`2<string,bool> assembly/'Pipe #4 input at line 44@46'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`2<string,bool>> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #4 input at line 44@46'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                              int32,
+                                                                                              class [runtime]System.Tuple`2<string,bool>)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #5 input at line 51@52-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'Pipe #5 input at line 51@52-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Product>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #5 input at line 51@52-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #5 input at line 51@52-1' assembly/'Pipe #5 input at line 51@52-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #5 input at line 51@53'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>>& next) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0027
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_008a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_007d
+
+      IL_0021:  nop
+      IL_0022:  br         IL_00ab
+
+      IL_0027:  nop
+      IL_0028:  ldarg.0
+      IL_0029:  ldsfld     class assembly/'Pipe #5 input at line 51@52-1' assembly/'Pipe #5 input at line 51@52-1'::@_instance
+      IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_0033:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                              class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0038:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_003d:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0042:  ldarg.0
+      IL_0043:  ldc.i4.1
+      IL_0044:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0049:  br.s       IL_007d
+
+      IL_004b:  ldarg.0
+      IL_004c:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0051:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_0056:  stloc.0
+      IL_0057:  ldarg.0
+      IL_0058:  ldc.i4.2
+      IL_0059:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_005e:  ldarg.0
+      IL_005f:  ldloc.0
+      IL_0060:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0065:  ldloc.0
+      IL_0066:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_006b:  ldloc.0
+      IL_006c:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_0071:  newobj     instance void class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                             !1,
+                                                                                                                                             !2)
+      IL_0076:  stfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+      IL_007b:  ldc.i4.1
+      IL_007c:  ret
+
+      IL_007d:  ldarg.0
+      IL_007e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0083:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0088:  brtrue.s   IL_004b
+
+      IL_008a:  ldarg.0
+      IL_008b:  ldc.i4.3
+      IL_008c:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0091:  ldarg.0
+      IL_0092:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_0097:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_009c:  nop
+      IL_009d:  ldarg.0
+      IL_009e:  ldnull
+      IL_009f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+      IL_00a4:  ldarg.0
+      IL_00a5:  ldc.i4.3
+      IL_00a6:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_00ab:  ldarg.0
+      IL_00ac:  ldnull
+      IL_00ad:  stfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+      IL_00b2:  ldc.i4.0
+      IL_00b3:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #5 input at line 51@53'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #5 input at line 51@53'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal> assembly/'Pipe #5 input at line 51@53'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #5 input at line 51@53'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                              int32,
+                                                                                              class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@60'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 59@60'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #6 input at line 59@60'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<int32,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@61-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@61-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.5
+      IL_0002:  clt
+      IL_0004:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@61-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@61-1' assembly/'Pipe #6 input at line 59@61-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #6 input at line 59@62-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,string>
+  {
+    .field static assembly initonly class assembly/'Pipe #6 input at line 59@62-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,string>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+      IL_0005:  ldarg.1
+      IL_0006:  tail.
+      IL_0008:  callvirt   instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Item(int32)
+      IL_000d:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #6 input at line 59@62-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #6 input at line 59@62-2' assembly/'Pipe #6 input at line 59@62-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 71@73-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 a
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 int32 a) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@73-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      int32 assembly/'Pipe #7 input at line 71@73-1'::a
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,object> Invoke(int32 _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@73-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      int32 assembly/'Pipe #7 input at line 71@73-1'::a
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<int32,int32>::.ctor(!0,
+                                                                                                  !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<int32,int32>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 71@72'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@72'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@72'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@72'::builder@
+      IL_000e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbersB()
+      IL_0013:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0018:  ldarg.0
+      IL_0019:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #7 input at line 71@72'::builder@
+      IL_001e:  ldloc.0
+      IL_001f:  newobj     instance void assembly/'Pipe #7 input at line 71@73-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                int32)
+      IL_0024:  tail.
+      IL_0026:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,int32>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 71@74-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<int32,int32>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 71@74-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<int32,int32>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<int32,int32> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<int32,int32>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<int32,int32>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  clt
+      IL_0012:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 71@74-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 71@74-2' assembly/'Pipe #7 input at line 71@74-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #7 input at line 71@75-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Tuple`2<int32,int32>>
+  {
+    .field static assembly initonly class assembly/'Pipe #7 input at line 71@75-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Tuple`2<int32,int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<int32,int32> Invoke(class [runtime]System.Tuple`2<int32,int32> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<int32,int32>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<int32,int32>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  ldloc.1
+      IL_0010:  newobj     instance void class [runtime]System.Tuple`2<int32,int32>::.ctor(!0,
+                                                                                                  !1)
+      IL_0015:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #7 input at line 71@75-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #7 input at line 71@75-3' assembly/'Pipe #7 input at line 71@75-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #8 input at line 81@83-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@83-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'Pipe #8 input at line 81@83-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@83-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'Pipe #8 input at line 81@83-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                           !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #8 input at line 81@82'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@82'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@82'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@82'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #8 input at line 81@82'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'Pipe #8 input at line 81@83-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #8 input at line 81@84-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #8 input at line 81@84-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Order::get_Total()
+      IL_0014:  ldc.i4     0xc350
+      IL_0019:  ldc.i4.0
+      IL_001a:  ldc.i4.0
+      IL_001b:  ldc.i4.0
+      IL_001c:  ldc.i4.2
+      IL_001d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                            int32,
+                                                                            int32,
+                                                                            bool,
+                                                                            uint8)
+      IL_0022:  call       bool [netstandard]System.Decimal::op_LessThan(valuetype [netstandard]System.Decimal,
+                                                                         valuetype [netstandard]System.Decimal)
+      IL_0027:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #8 input at line 81@84-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #8 input at line 81@84-2' assembly/'Pipe #8 input at line 81@84-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #8 input at line 81@85-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'Pipe #8 input at line 81@85-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Order::get_Total()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                            !1,
+                                                                                                                                            !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #8 input at line 81@85-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #8 input at line 81@85-3' assembly/'Pipe #8 input at line 81@85-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #9 input at line 90@92-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@92-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'Pipe #9 input at line 90@92-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@92-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'Pipe #9 input at line 90@92-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                           !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #9 input at line 90@91'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@91'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@91'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@91'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #9 input at line 90@91'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'Pipe #9 input at line 90@92-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                                class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #9 input at line 90@93-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #9 input at line 90@93-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1,
+               valuetype [runtime]System.DateTime V_2,
+               valuetype [runtime]System.DateTime V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0014:  stloc.2
+      IL_0015:  ldc.i4     0x7ce
+      IL_001a:  ldc.i4.1
+      IL_001b:  ldc.i4.1
+      IL_001c:  newobj     instance void [runtime]System.DateTime::.ctor(int32,
+                                                                                int32,
+                                                                                int32)
+      IL_0021:  stloc.3
+      IL_0022:  ldloc.2
+      IL_0023:  ldloc.3
+      IL_0024:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_0029:  ldc.i4.0
+      IL_002a:  clt
+      IL_002c:  ldc.i4.0
+      IL_002d:  ceq
+      IL_002f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #9 input at line 90@93-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #9 input at line 90@93-2' assembly/'Pipe #9 input at line 90@93-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #9 input at line 90@94-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>
+  {
+    .field static assembly initonly class assembly/'Pipe #9 input at line 90@94-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>::.ctor(!0,
+                                                                                                                                             !1,
+                                                                                                                                             !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #9 input at line 90@94-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #9 input at line 90@94-3' assembly/'Pipe #9 input at line 90@94-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders3@101-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders3@101-1'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'orders3@101-1'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg2) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders3@101-1'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'orders3@101-1'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                           !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit orders3@100
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders3@100::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders3@100::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders3@100::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders3@100::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'orders3@101-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders3@102-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'orders3@102-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  10
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Order::get_Total()
+      IL_0014:  ldc.i4     0x4e20
+      IL_0019:  ldc.i4.0
+      IL_001a:  ldc.i4.0
+      IL_001b:  ldc.i4.0
+      IL_001c:  ldc.i4.1
+      IL_001d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                            int32,
+                                                                            int32,
+                                                                            bool,
+                                                                            uint8)
+      IL_0022:  call       bool [netstandard]System.Decimal::op_GreaterThanOrEqual(valuetype [netstandard]System.Decimal,
+                                                                                   valuetype [netstandard]System.Decimal)
+      IL_0027:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders3@102-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders3@102-2' assembly/'orders3@102-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders3@103-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>
+  {
+    .field static assembly initonly class assembly/'orders3@103-3' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  ldloc.1
+      IL_001b:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Order::get_Total()
+      IL_0020:  newobj     instance void class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>::.ctor(!0,
+                                                                                                                                            !1,
+                                                                                                                                            !2)
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders3@103-3'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders3@103-3' assembly/'orders3@103-3'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit orders4@111
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders4@111::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/orders4@111::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Customer,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@112-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,bool>
+  {
+    .field static assembly initonly class assembly/'orders4@112-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Customer c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance string [Utils]Utils/Customer::get_Region()
+      IL_0006:  ldstr      "WA"
+      IL_000b:  call       bool [netstandard]System.String::Equals(string,
+                                                                   string)
+      IL_0010:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders4@112-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders4@112-1' assembly/'orders4@112-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@113-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public class [Utils]Utils/Customer c
+    .method assembly specialname rtspecialname 
+            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@,
+                                 class [Utils]Utils/Customer c) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Order,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@113-3'::builder@
+      IL_000d:  ldarg.0
+      IL_000e:  ldarg.2
+      IL_000f:  stfld      class [Utils]Utils/Customer assembly/'orders4@113-3'::c
+      IL_0014:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object> Invoke(class [Utils]Utils/Order _arg3) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Order V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@113-3'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [Utils]Utils/Customer assembly/'orders4@113-3'::c
+      IL_000e:  ldloc.0
+      IL_000f:  newobj     instance void class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::.ctor(!0,
+                                                                                                                                           !1)
+      IL_0014:  tail.
+      IL_0016:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(!!0)
+      IL_001b:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@111-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@111-2'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable> Invoke(class [Utils]Utils/Customer _arg2) cil managed
+    {
+      
+      .maxstack  8
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@111-2'::builder@
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@111-2'::builder@
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance class [Utils]Utils/Order[] [Utils]Utils/Customer::get_Orders()
+      IL_0014:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Order>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'orders4@111-2'::builder@
+      IL_001f:  ldloc.0
+      IL_0020:  newobj     instance void assembly/'orders4@113-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder,
+                                                                                class [Utils]Utils/Customer)
+      IL_0025:  tail.
+      IL_0027:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Order,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+      IL_002c:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@114-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>
+  {
+    .field static assembly initonly class assembly/'orders4@114-4' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1,
+               valuetype [runtime]System.DateTime V_2,
+               valuetype [runtime]System.DateTime V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.1
+      IL_000f:  callvirt   instance valuetype [runtime]System.DateTime [Utils]Utils/Order::get_OrderDate()
+      IL_0014:  stloc.2
+      IL_0015:  call       valuetype [runtime]System.DateTime assembly::get_cutOffDate()
+      IL_001a:  stloc.3
+      IL_001b:  ldloc.2
+      IL_001c:  ldloc.3
+      IL_001d:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_0022:  ldc.i4.0
+      IL_0023:  clt
+      IL_0025:  ldc.i4.0
+      IL_0026:  ceq
+      IL_0028:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders4@114-4'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders4@114-4' assembly/'orders4@114-4'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'orders4@115-5'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`2<string,int32>>
+  {
+    .field static assembly initonly class assembly/'orders4@115-5' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Tuple`2<string,int32>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Tuple`2<string,int32> Invoke(class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order> tupledArg) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0,
+               class [Utils]Utils/Order V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  call       instance !0 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item1()
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.1
+      IL_0008:  call       instance !1 class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>::get_Item2()
+      IL_000d:  stloc.1
+      IL_000e:  ldloc.0
+      IL_000f:  callvirt   instance string [Utils]Utils/Customer::get_CustomerID()
+      IL_0014:  ldloc.1
+      IL_0015:  callvirt   instance int32 [Utils]Utils/Order::get_OrderID()
+      IL_001a:  newobj     instance void class [runtime]System.Tuple`2<string,int32>::.ctor(!0,
+                                                                                                   !1)
+      IL_001f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'orders4@115-5'::.ctor()
+      IL_0005:  stsfld     class assembly/'orders4@115-5' assembly/'orders4@115-5'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@7
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numsPlusOne@10
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<string> productNames@19
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> strings@26
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> textNums@27
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> words@34
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<string,string>[] upperLowerWords@36
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> digitOddEvens@43
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] productInfos@50
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> digits@57
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> lowNums@58
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbersA@67
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbersB@68
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`2<int32,int32>[] pairs@70
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@79
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] orders@80
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] orders2@89
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> orders3@98
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly valuetype [runtime]System.DateTime cutOffDate@107
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> orders4@109
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@7
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numsPlusOne() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numsPlusOne@10
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@17
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<string> get_productNames() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::productNames@19
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_strings() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::strings@26
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_textNums() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::textNums@27
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_words() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@34
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<string,string>[] get_upperLowerWords() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<string,string>[] assembly::upperLowerWords@36
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> get_digitOddEvens() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> assembly::digitOddEvens@43
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] get_productInfos() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] assembly::productInfos@50
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_digits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@57
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_lowNums() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::lowNums@58
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbersA() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbersA@67
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbersB() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbersB@68
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`2<int32,int32>[] get_pairs() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`2<int32,int32>[] assembly::pairs@70
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@79
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] get_orders() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] assembly::orders@80
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] get_orders2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::orders2@89
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> get_orders3() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> assembly::orders3@98
+    IL_0005:  ret
+  } 
+
+  .method public specialname static valuetype [runtime]System.DateTime get_cutOffDate() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     valuetype [runtime]System.DateTime assembly::cutOffDate@107
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> get_orders4() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> assembly::orders4@109
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_3,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_4,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,string>> V_5,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_6,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,bool>> V_7,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_8,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>> V_9,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_10,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_11,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_12,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> V_13,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> V_14,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<int32,int32>> V_15,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_16,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> V_17,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_18,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>> V_19,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_20,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_21,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_22)
+    IL_0000:  ldc.i4.5
+    IL_0001:  ldc.i4.4
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.3
+    IL_0004:  ldc.i4.s   9
+    IL_0006:  ldc.i4.8
+    IL_0007:  ldc.i4.6
+    IL_0008:  ldc.i4.7
+    IL_0009:  ldc.i4.2
+    IL_000a:  ldc.i4.0
+    IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0010:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0015:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0024:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0029:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0033:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_003d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0042:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@7
+    IL_0047:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_004c:  stloc.1
+    IL_004d:  ldnull
+    IL_004e:  ldc.i4.0
+    IL_004f:  ldc.i4.0
+    IL_0050:  newobj     instance void assembly/'Pipe #1 input at line 11@13'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                            int32,
+                                                                                            int32)
+    IL_0055:  stloc.0
+    IL_0056:  ldloc.0
+    IL_0057:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_005c:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numsPlusOne@10
+    IL_0061:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0066:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@17
+    IL_006b:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0070:  stloc.2
+    IL_0071:  ldnull
+    IL_0072:  ldc.i4.0
+    IL_0073:  ldnull
+    IL_0074:  newobj     instance void assembly/productNames@22::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                              int32,
+                                                                              string)
+    IL_0079:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::productNames@19
+    IL_007e:  ldstr      "zero"
+    IL_0083:  ldstr      "one"
+    IL_0088:  ldstr      "two"
+    IL_008d:  ldstr      "three"
+    IL_0092:  ldstr      "four"
+    IL_0097:  ldstr      "five"
+    IL_009c:  ldstr      "six"
+    IL_00a1:  ldstr      "seven"
+    IL_00a6:  ldstr      "eight"
+    IL_00ab:  ldstr      "nine"
+    IL_00b0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_00b5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00ba:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00bf:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00c4:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00c9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00ce:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00d3:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00d8:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00dd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00e2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_00e7:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::strings@26
+    IL_00ec:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00f1:  stloc.s    V_4
+    IL_00f3:  ldnull
+    IL_00f4:  ldc.i4.0
+    IL_00f5:  ldnull
+    IL_00f6:  newobj     instance void assembly/'Pipe #2 input at line 28@30'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                            int32,
+                                                                                            string)
+    IL_00fb:  stloc.3
+    IL_00fc:  ldloc.3
+    IL_00fd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0102:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::textNums@27
+    IL_0107:  ldstr      "aPPLE"
+    IL_010c:  ldstr      "BlUeBeRrY"
+    IL_0111:  ldstr      "cHeRry"
+    IL_0116:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_011b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0120:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0125:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_012a:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::words@34
+    IL_012f:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0134:  stloc.s    V_6
+    IL_0136:  ldnull
+    IL_0137:  ldc.i4.0
+    IL_0138:  ldnull
+    IL_0139:  newobj     instance void assembly/'Pipe #3 input at line 37@39'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                            int32,
+                                                                                            class [runtime]System.Tuple`2<string,string>)
+    IL_013e:  stloc.s    V_5
+    IL_0140:  ldloc.s    V_5
+    IL_0142:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<string,string>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0147:  stsfld     class [runtime]System.Tuple`2<string,string>[] assembly::upperLowerWords@36
+    IL_014c:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0151:  stloc.s    V_8
+    IL_0153:  ldnull
+    IL_0154:  ldc.i4.0
+    IL_0155:  ldnull
+    IL_0156:  newobj     instance void assembly/'Pipe #4 input at line 44@46'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                            int32,
+                                                                                            class [runtime]System.Tuple`2<string,bool>)
+    IL_015b:  stloc.s    V_7
+    IL_015d:  ldloc.s    V_7
+    IL_015f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<class [runtime]System.Tuple`2<string,bool>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0164:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> assembly::digitOddEvens@43
+    IL_0169:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_016e:  stloc.s    V_10
+    IL_0170:  ldnull
+    IL_0171:  ldc.i4.0
+    IL_0172:  ldnull
+    IL_0173:  newobj     instance void assembly/'Pipe #5 input at line 51@53'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                            int32,
+                                                                                            class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>)
+    IL_0178:  stloc.s    V_9
+    IL_017a:  ldloc.s    V_9
+    IL_017c:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0181:  stsfld     class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] assembly::productInfos@50
+    IL_0186:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+    IL_018b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@57
+    IL_0190:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0195:  stloc.s    V_12
+    IL_0197:  ldloc.s    V_12
+    IL_0199:  ldloc.s    V_12
+    IL_019b:  ldloc.s    V_12
+    IL_019d:  ldloc.s    V_12
+    IL_019f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+    IL_01a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01a9:  ldloc.s    V_12
+    IL_01ab:  newobj     instance void assembly/'Pipe #6 input at line 59@60'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_01b0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,int32,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_01b5:  ldsfld     class assembly/'Pipe #6 input at line 59@61-1' assembly/'Pipe #6 input at line 59@61-1'::@_instance
+    IL_01ba:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_01bf:  ldsfld     class assembly/'Pipe #6 input at line 59@62-2' assembly/'Pipe #6 input at line 59@62-2'::@_instance
+    IL_01c4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<int32,class [runtime]System.Collections.IEnumerable,string>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_01c9:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_01ce:  stloc.s    V_11
+    IL_01d0:  ldloc.s    V_11
+    IL_01d2:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01d7:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::lowNums@58
+    IL_01dc:  nop
+    IL_01dd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_lowNums()
+    IL_01e2:  stloc.s    V_13
+    IL_01e4:  ldstr      "four"
+    IL_01e9:  ldstr      "one"
+    IL_01ee:  ldstr      "three"
+    IL_01f3:  ldstr      "two"
+    IL_01f8:  ldstr      "zero"
+    IL_01fd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_0202:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0207:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_020c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0211:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0216:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_021b:  stloc.s    V_14
+    IL_021d:  ldloc.s    V_13
+    IL_021f:  ldloc.s    V_14
+    IL_0221:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0226:  callvirt   instance bool class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Equals(object,
+                                                                                                                    class [runtime]System.Collections.IEqualityComparer)
+    IL_022b:  ldc.i4.0
+    IL_022c:  ceq
+    IL_022e:  brfalse.s  IL_024a
+
+    IL_0230:  ldstr      "lowNums failed"
+    IL_0235:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_023a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_023f:  pop
+    IL_0240:  ldc.i4.1
+    IL_0241:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Exit<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(int32)
+    IL_0246:  pop
+    IL_0247:  nop
+    IL_0248:  br.s       IL_024b
+
+    IL_024a:  nop
+    IL_024b:  ldc.i4.0
+    IL_024c:  ldc.i4.2
+    IL_024d:  ldc.i4.4
+    IL_024e:  ldc.i4.5
+    IL_024f:  ldc.i4.6
+    IL_0250:  ldc.i4.8
+    IL_0251:  ldc.i4.s   9
+    IL_0253:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0258:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_025d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0262:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0267:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_026c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0271:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0276:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_027b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbersA@67
+    IL_0280:  ldc.i4.1
+    IL_0281:  ldc.i4.3
+    IL_0282:  ldc.i4.5
+    IL_0283:  ldc.i4.7
+    IL_0284:  ldc.i4.8
+    IL_0285:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_028a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_028f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0294:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0299:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_029e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_02a3:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbersB@68
+    IL_02a8:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_02ad:  stloc.s    V_16
+    IL_02af:  ldloc.s    V_16
+    IL_02b1:  ldloc.s    V_16
+    IL_02b3:  ldloc.s    V_16
+    IL_02b5:  ldloc.s    V_16
+    IL_02b7:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbersA()
+    IL_02bc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_02c1:  ldloc.s    V_16
+    IL_02c3:  newobj     instance void assembly/'Pipe #7 input at line 71@72'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_02c8:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_02cd:  ldsfld     class assembly/'Pipe #7 input at line 71@74-2' assembly/'Pipe #7 input at line 71@74-2'::@_instance
+    IL_02d2:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_02d7:  ldsfld     class assembly/'Pipe #7 input at line 71@75-3' assembly/'Pipe #7 input at line 71@75-3'::@_instance
+    IL_02dc:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<int32,int32>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_02e1:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<int32,int32>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_02e6:  stloc.s    V_15
+    IL_02e8:  ldloc.s    V_15
+    IL_02ea:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`2<int32,int32>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_02ef:  stsfld     class [runtime]System.Tuple`2<int32,int32>[] assembly::pairs@70
+    IL_02f4:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_02f9:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@79
+    IL_02fe:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0303:  stloc.s    V_18
+    IL_0305:  ldloc.s    V_18
+    IL_0307:  ldloc.s    V_18
+    IL_0309:  ldloc.s    V_18
+    IL_030b:  ldloc.s    V_18
+    IL_030d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_0312:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0317:  ldloc.s    V_18
+    IL_0319:  newobj     instance void assembly/'Pipe #8 input at line 81@82'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_031e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0323:  ldsfld     class assembly/'Pipe #8 input at line 81@84-2' assembly/'Pipe #8 input at line 81@84-2'::@_instance
+    IL_0328:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_032d:  ldsfld     class assembly/'Pipe #8 input at line 81@85-3' assembly/'Pipe #8 input at line 81@85-3'::@_instance
+    IL_0332:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0337:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_033c:  stloc.s    V_17
+    IL_033e:  ldloc.s    V_17
+    IL_0340:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0345:  stsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] assembly::orders@80
+    IL_034a:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_034f:  stloc.s    V_20
+    IL_0351:  ldloc.s    V_20
+    IL_0353:  ldloc.s    V_20
+    IL_0355:  ldloc.s    V_20
+    IL_0357:  ldloc.s    V_20
+    IL_0359:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_035e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0363:  ldloc.s    V_20
+    IL_0365:  newobj     instance void assembly/'Pipe #9 input at line 90@91'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_036a:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_036f:  ldsfld     class assembly/'Pipe #9 input at line 90@93-2' assembly/'Pipe #9 input at line 90@93-2'::@_instance
+    IL_0374:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0379:  ldsfld     class assembly/'Pipe #9 input at line 90@94-3' assembly/'Pipe #9 input at line 90@94-3'::@_instance
+    IL_037e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0383:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0388:  stloc.s    V_19
+    IL_038a:  ldloc.s    V_19
+    IL_038c:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0391:  stsfld     class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::orders2@89
+    IL_0396:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_039b:  stloc.s    V_21
+    IL_039d:  ldloc.s    V_21
+    IL_039f:  ldloc.s    V_21
+    IL_03a1:  ldloc.s    V_21
+    IL_03a3:  ldloc.s    V_21
+    IL_03a5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_03aa:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_03af:  ldloc.s    V_21
+    IL_03b1:  newobj     instance void assembly/orders3@100::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_03b6:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_03bb:  ldsfld     class assembly/'orders3@102-2' assembly/'orders3@102-2'::@_instance
+    IL_03c0:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_03c5:  ldsfld     class assembly/'orders3@103-3' assembly/'orders3@103-3'::@_instance
+    IL_03ca:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                                       class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_03cf:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_03d4:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> assembly::orders3@98
+    IL_03d9:  ldc.i4     0x7cd
+    IL_03de:  ldc.i4.1
+    IL_03df:  ldc.i4.1
+    IL_03e0:  newobj     instance void [runtime]System.DateTime::.ctor(int32,
+                                                                              int32,
+                                                                              int32)
+    IL_03e5:  stsfld     valuetype [runtime]System.DateTime assembly::cutOffDate@107
+    IL_03ea:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_03ef:  stloc.s    V_22
+    IL_03f1:  ldloc.s    V_22
+    IL_03f3:  ldloc.s    V_22
+    IL_03f5:  ldloc.s    V_22
+    IL_03f7:  ldloc.s    V_22
+    IL_03f9:  ldloc.s    V_22
+    IL_03fb:  ldloc.s    V_22
+    IL_03fd:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_0402:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0407:  ldloc.s    V_22
+    IL_0409:  newobj     instance void assembly/orders4@111::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_040e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Customer,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0413:  ldsfld     class assembly/'orders4@112-1' assembly/'orders4@112-1'::@_instance
+    IL_0418:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_041d:  ldloc.s    V_22
+    IL_041f:  newobj     instance void assembly/'orders4@111-2'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0424:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                                                         class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0429:  ldsfld     class assembly/'orders4@114-4' assembly/'orders4@114-4'::@_instance
+    IL_042e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0433:  ldsfld     class assembly/'orders4@115-5' assembly/'orders4@115-5'::@_instance
+    IL_0438:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [runtime]System.Tuple`2<class [Utils]Utils/Customer,class [Utils]Utils/Order>,class [runtime]System.Collections.IEnumerable,class [runtime]System.Tuple`2<string,int32>>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_043d:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [runtime]System.Tuple`2<string,int32>,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0442:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> assembly::orders4@109
+    IL_0447:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numsPlusOne()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numsPlusOne()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<string>
+          productNames()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::get_productNames()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          strings()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_strings()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          textNums()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_textNums()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          words()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_words()
+  } 
+  .property class [runtime]System.Tuple`2<string,string>[]
+          upperLowerWords()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<string,string>[] assembly::get_upperLowerWords()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>>
+          digitOddEvens()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [runtime]System.Tuple`2<string,bool>> assembly::get_digitOddEvens()
+  } 
+  .property class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[]
+          productInfos()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`3<string,string,valuetype [runtime]System.Decimal>[] assembly::get_productInfos()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          digits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          lowNums()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_lowNums()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbersA()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbersA()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbersB()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbersB()
+  } 
+  .property class [runtime]System.Tuple`2<int32,int32>[]
+          pairs()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`2<int32,int32>[] assembly::get_pairs()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[]
+          orders()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>[] assembly::get_orders()
+  } 
+  .property class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[]
+          orders2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.DateTime>[] assembly::get_orders2()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>>
+          orders3()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`3<string,int32,valuetype [runtime]System.Decimal>> assembly::get_orders3()
+  } 
+  .property valuetype [runtime]System.DateTime
+          cutOffDate()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get valuetype [runtime]System.DateTime assembly::get_cutOffDate()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>>
+          orders4()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [runtime]System.Tuple`2<string,int32>> assembly::get_orders4()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOff.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOff.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOff.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOff.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOff.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOff.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOn.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOn.il.net472.debug.bsl
new file mode 100644
index 00000000000..4fc8a2245fd
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOn.il.net472.debug.bsl
@@ -0,0 +1,1439 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 12@13'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_factorsOf300()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 12@13'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 21@22-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 21@22-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Product>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 21@22-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 21@22-1' assembly/'Pipe #2 input at line 21@22-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #2 input at line 21@23'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #2 input at line 21@23'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0076
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0069
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0097
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'Pipe #2 input at line 21@22-1' assembly/'Pipe #2 input at line 21@22-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                  class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0046:  br.s       IL_0069
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0062:  stfld      string assembly/'Pipe #2 input at line 21@23'::current
+      IL_0067:  ldc.i4.1
+      IL_0068:  ret
+
+      IL_0069:  ldarg.0
+      IL_006a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_006f:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0074:  brtrue.s   IL_0048
+
+      IL_0076:  ldarg.0
+      IL_0077:  ldc.i4.3
+      IL_0078:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_007d:  ldarg.0
+      IL_007e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_0083:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_0088:  nop
+      IL_0089:  ldarg.0
+      IL_008a:  ldnull
+      IL_008b:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_0090:  ldarg.0
+      IL_0091:  ldc.i4.3
+      IL_0092:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0097:  ldarg.0
+      IL_0098:  ldnull
+      IL_0099:  stfld      string assembly/'Pipe #2 input at line 21@23'::current
+      IL_009e:  ldc.i4.0
+      IL_009f:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #2 input at line 21@23'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #2 input at line 21@23'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #2 input at line 21@23'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                                    int32,
+                                                                                                    string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'productFirstChars@32-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'productFirstChars@32-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Product>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'productFirstChars@32-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'productFirstChars@32-1' assembly/'productFirstChars@32-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname productFirstChars@33
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<char>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public char current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 char current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      char assembly/productFirstChars@33::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<char>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<char>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productFirstChars@33::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_007c
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_006f
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_009d
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'productFirstChars@32-1' assembly/'productFirstChars@32-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                  class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_0046:  br.s       IL_006f
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0062:  ldc.i4.0
+      IL_0063:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+      IL_0068:  stfld      char assembly/productFirstChars@33::current
+      IL_006d:  ldc.i4.1
+      IL_006e:  ret
+
+      IL_006f:  ldarg.0
+      IL_0070:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_0075:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_007a:  brtrue.s   IL_0048
+
+      IL_007c:  ldarg.0
+      IL_007d:  ldc.i4.3
+      IL_007e:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_0083:  ldarg.0
+      IL_0084:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_0089:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_008e:  nop
+      IL_008f:  ldarg.0
+      IL_0090:  ldnull
+      IL_0091:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_0096:  ldarg.0
+      IL_0097:  ldc.i4.3
+      IL_0098:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_009d:  ldarg.0
+      IL_009e:  ldc.i4.0
+      IL_009f:  stfld      char assembly/productFirstChars@33::current
+      IL_00a4:  ldc.i4.0
+      IL_00a5:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productFirstChars@33::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/productFirstChars@33::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/productFirstChars@33::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/productFirstChars@33::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      char assembly/productFirstChars@33::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productFirstChars@33::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance char get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      char assembly/productFirstChars@33::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<char> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/productFirstChars@33::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                           int32,
+                                                                                           char)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'customerFirstChars@38-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer>>
+  {
+    .field static assembly initonly class assembly/'customerFirstChars@38-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Customer>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'customerFirstChars@38-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'customerFirstChars@38-1' assembly/'customerFirstChars@38-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname customerFirstChars@39
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<char>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public char current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> 'enum',
+                                 int32 pc,
+                                 char current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      char assembly/customerFirstChars@39::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<char>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<char>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/customerFirstChars@39::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_007c
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_006f
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_009d
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'customerFirstChars@38-1' assembly/'customerFirstChars@38-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer>,class [Utils]Utils/Customer>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                     class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_0046:  br.s       IL_006f
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  callvirt   instance string [Utils]Utils/Customer::get_CompanyName()
+      IL_0062:  ldc.i4.0
+      IL_0063:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+      IL_0068:  stfld      char assembly/customerFirstChars@39::current
+      IL_006d:  ldc.i4.1
+      IL_006e:  ret
+
+      IL_006f:  ldarg.0
+      IL_0070:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_0075:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_007a:  brtrue.s   IL_0048
+
+      IL_007c:  ldarg.0
+      IL_007d:  ldc.i4.3
+      IL_007e:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_0083:  ldarg.0
+      IL_0084:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_0089:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>>(!!0)
+      IL_008e:  nop
+      IL_008f:  ldarg.0
+      IL_0090:  ldnull
+      IL_0091:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_0096:  ldarg.0
+      IL_0097:  ldc.i4.3
+      IL_0098:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_009d:  ldarg.0
+      IL_009e:  ldc.i4.0
+      IL_009f:  stfld      char assembly/customerFirstChars@39::current
+      IL_00a4:  ldc.i4.0
+      IL_00a5:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/customerFirstChars@39::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/customerFirstChars@39::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/customerFirstChars@39::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/customerFirstChars@39::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      char assembly/customerFirstChars@39::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/customerFirstChars@39::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance char get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      char assembly/customerFirstChars@39::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<char> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/customerFirstChars@39::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>,
+                                                                                            int32,
+                                                                                            char)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> factorsOf300@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> uniqueFactors@11
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@18
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> categoryNames@20
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@28
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<char> productFirstChars@30
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<char> customerFirstChars@36
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_factorsOf300() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::factorsOf300@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_uniqueFactors() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::uniqueFactors@11
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@18
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_categoryNames() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::categoryNames@20
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@28
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<char> get_productFirstChars() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::productFirstChars@30
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<char> get_customerFirstChars() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::customerFirstChars@36
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5)
+    IL_0000:  ldc.i4.2
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  ldc.i4.5
+    IL_0004:  ldc.i4.5
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::factorsOf300@9
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_002d:  stloc.1
+    IL_002e:  ldloc.1
+    IL_002f:  ldnull
+    IL_0030:  ldc.i4.0
+    IL_0031:  ldc.i4.0
+    IL_0032:  newobj     instance void assembly/'Pipe #1 input at line 12@13'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_0037:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_003c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Distinct<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_0041:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0046:  stloc.0
+    IL_0047:  ldloc.0
+    IL_0048:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_004d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::uniqueFactors@11
+    IL_0052:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0057:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@18
+    IL_005c:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0061:  stloc.3
+    IL_0062:  ldloc.3
+    IL_0063:  ldnull
+    IL_0064:  ldc.i4.0
+    IL_0065:  ldnull
+    IL_0066:  newobj     instance void assembly/'Pipe #2 input at line 21@23'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                                  int32,
+                                                                                                  string)
+    IL_006b:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0070:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Distinct<string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_0075:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_007a:  stloc.2
+    IL_007b:  ldloc.2
+    IL_007c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0081:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::categoryNames@20
+    IL_0086:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_008b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@28
+    IL_0090:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0095:  stloc.s    V_4
+    IL_0097:  ldnull
+    IL_0098:  ldc.i4.0
+    IL_0099:  ldc.i4.0
+    IL_009a:  newobj     instance void assembly/productFirstChars@33::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                         int32,
+                                                                                         char)
+    IL_009f:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::productFirstChars@30
+    IL_00a4:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00a9:  stloc.s    V_5
+    IL_00ab:  ldnull
+    IL_00ac:  ldc.i4.0
+    IL_00ad:  ldc.i4.0
+    IL_00ae:  newobj     instance void assembly/customerFirstChars@39::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>,
+                                                                                          int32,
+                                                                                          char)
+    IL_00b3:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::customerFirstChars@36
+    IL_00b8:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          factorsOf300()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_factorsOf300()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          uniqueFactors()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_uniqueFactors()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          categoryNames()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categoryNames()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<char>
+          productFirstChars()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::get_productFirstChars()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<char>
+          customerFirstChars()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::get_customerFirstChars()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOn.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOn.il.net472.release.bsl
new file mode 100644
index 00000000000..4fc8a2245fd
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOn.il.net472.release.bsl
@@ -0,0 +1,1439 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 12@13'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_factorsOf300()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 12@13'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 21@22-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 21@22-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Product>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 21@22-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 21@22-1' assembly/'Pipe #2 input at line 21@22-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #2 input at line 21@23'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #2 input at line 21@23'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0076
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0069
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0097
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'Pipe #2 input at line 21@22-1' assembly/'Pipe #2 input at line 21@22-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                  class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0046:  br.s       IL_0069
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0062:  stfld      string assembly/'Pipe #2 input at line 21@23'::current
+      IL_0067:  ldc.i4.1
+      IL_0068:  ret
+
+      IL_0069:  ldarg.0
+      IL_006a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_006f:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0074:  brtrue.s   IL_0048
+
+      IL_0076:  ldarg.0
+      IL_0077:  ldc.i4.3
+      IL_0078:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_007d:  ldarg.0
+      IL_007e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_0083:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_0088:  nop
+      IL_0089:  ldarg.0
+      IL_008a:  ldnull
+      IL_008b:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_0090:  ldarg.0
+      IL_0091:  ldc.i4.3
+      IL_0092:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0097:  ldarg.0
+      IL_0098:  ldnull
+      IL_0099:  stfld      string assembly/'Pipe #2 input at line 21@23'::current
+      IL_009e:  ldc.i4.0
+      IL_009f:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #2 input at line 21@23'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #2 input at line 21@23'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #2 input at line 21@23'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                                    int32,
+                                                                                                    string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'productFirstChars@32-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'productFirstChars@32-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Product>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'productFirstChars@32-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'productFirstChars@32-1' assembly/'productFirstChars@32-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname productFirstChars@33
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<char>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public char current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 char current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      char assembly/productFirstChars@33::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<char>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<char>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productFirstChars@33::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_007c
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_006f
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_009d
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'productFirstChars@32-1' assembly/'productFirstChars@32-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                  class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_0046:  br.s       IL_006f
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0062:  ldc.i4.0
+      IL_0063:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+      IL_0068:  stfld      char assembly/productFirstChars@33::current
+      IL_006d:  ldc.i4.1
+      IL_006e:  ret
+
+      IL_006f:  ldarg.0
+      IL_0070:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_0075:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_007a:  brtrue.s   IL_0048
+
+      IL_007c:  ldarg.0
+      IL_007d:  ldc.i4.3
+      IL_007e:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_0083:  ldarg.0
+      IL_0084:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_0089:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_008e:  nop
+      IL_008f:  ldarg.0
+      IL_0090:  ldnull
+      IL_0091:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_0096:  ldarg.0
+      IL_0097:  ldc.i4.3
+      IL_0098:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_009d:  ldarg.0
+      IL_009e:  ldc.i4.0
+      IL_009f:  stfld      char assembly/productFirstChars@33::current
+      IL_00a4:  ldc.i4.0
+      IL_00a5:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productFirstChars@33::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/productFirstChars@33::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/productFirstChars@33::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/productFirstChars@33::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      char assembly/productFirstChars@33::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productFirstChars@33::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance char get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      char assembly/productFirstChars@33::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<char> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/productFirstChars@33::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                           int32,
+                                                                                           char)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'customerFirstChars@38-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer>>
+  {
+    .field static assembly initonly class assembly/'customerFirstChars@38-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Customer>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'customerFirstChars@38-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'customerFirstChars@38-1' assembly/'customerFirstChars@38-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname customerFirstChars@39
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<char>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public char current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> 'enum',
+                                 int32 pc,
+                                 char current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      char assembly/customerFirstChars@39::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<char>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<char>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/customerFirstChars@39::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_007c
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_006f
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_009d
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'customerFirstChars@38-1' assembly/'customerFirstChars@38-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer>,class [Utils]Utils/Customer>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                     class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_0046:  br.s       IL_006f
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  callvirt   instance string [Utils]Utils/Customer::get_CompanyName()
+      IL_0062:  ldc.i4.0
+      IL_0063:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+      IL_0068:  stfld      char assembly/customerFirstChars@39::current
+      IL_006d:  ldc.i4.1
+      IL_006e:  ret
+
+      IL_006f:  ldarg.0
+      IL_0070:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_0075:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_007a:  brtrue.s   IL_0048
+
+      IL_007c:  ldarg.0
+      IL_007d:  ldc.i4.3
+      IL_007e:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_0083:  ldarg.0
+      IL_0084:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_0089:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>>(!!0)
+      IL_008e:  nop
+      IL_008f:  ldarg.0
+      IL_0090:  ldnull
+      IL_0091:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_0096:  ldarg.0
+      IL_0097:  ldc.i4.3
+      IL_0098:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_009d:  ldarg.0
+      IL_009e:  ldc.i4.0
+      IL_009f:  stfld      char assembly/customerFirstChars@39::current
+      IL_00a4:  ldc.i4.0
+      IL_00a5:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/customerFirstChars@39::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/customerFirstChars@39::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/customerFirstChars@39::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/customerFirstChars@39::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      char assembly/customerFirstChars@39::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/customerFirstChars@39::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance char get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      char assembly/customerFirstChars@39::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<char> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/customerFirstChars@39::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>,
+                                                                                            int32,
+                                                                                            char)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> factorsOf300@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> uniqueFactors@11
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@18
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> categoryNames@20
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@28
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<char> productFirstChars@30
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<char> customerFirstChars@36
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_factorsOf300() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::factorsOf300@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_uniqueFactors() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::uniqueFactors@11
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@18
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_categoryNames() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::categoryNames@20
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@28
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<char> get_productFirstChars() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::productFirstChars@30
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<char> get_customerFirstChars() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::customerFirstChars@36
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5)
+    IL_0000:  ldc.i4.2
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  ldc.i4.5
+    IL_0004:  ldc.i4.5
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::factorsOf300@9
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_002d:  stloc.1
+    IL_002e:  ldloc.1
+    IL_002f:  ldnull
+    IL_0030:  ldc.i4.0
+    IL_0031:  ldc.i4.0
+    IL_0032:  newobj     instance void assembly/'Pipe #1 input at line 12@13'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_0037:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_003c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Distinct<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_0041:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0046:  stloc.0
+    IL_0047:  ldloc.0
+    IL_0048:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_004d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::uniqueFactors@11
+    IL_0052:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0057:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@18
+    IL_005c:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0061:  stloc.3
+    IL_0062:  ldloc.3
+    IL_0063:  ldnull
+    IL_0064:  ldc.i4.0
+    IL_0065:  ldnull
+    IL_0066:  newobj     instance void assembly/'Pipe #2 input at line 21@23'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                                  int32,
+                                                                                                  string)
+    IL_006b:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0070:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Distinct<string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_0075:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_007a:  stloc.2
+    IL_007b:  ldloc.2
+    IL_007c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0081:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::categoryNames@20
+    IL_0086:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_008b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@28
+    IL_0090:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0095:  stloc.s    V_4
+    IL_0097:  ldnull
+    IL_0098:  ldc.i4.0
+    IL_0099:  ldc.i4.0
+    IL_009a:  newobj     instance void assembly/productFirstChars@33::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                         int32,
+                                                                                         char)
+    IL_009f:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::productFirstChars@30
+    IL_00a4:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00a9:  stloc.s    V_5
+    IL_00ab:  ldnull
+    IL_00ac:  ldc.i4.0
+    IL_00ad:  ldc.i4.0
+    IL_00ae:  newobj     instance void assembly/customerFirstChars@39::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>,
+                                                                                          int32,
+                                                                                          char)
+    IL_00b3:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::customerFirstChars@36
+    IL_00b8:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          factorsOf300()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_factorsOf300()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          uniqueFactors()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_uniqueFactors()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          categoryNames()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categoryNames()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<char>
+          productFirstChars()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::get_productFirstChars()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<char>
+          customerFirstChars()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::get_customerFirstChars()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOn.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
new file mode 100644
index 00000000000..303f6f4ed2f
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
@@ -0,0 +1,1439 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 12@13'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_factorsOf300()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 12@13'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 21@22-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 21@22-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Product>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 21@22-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 21@22-1' assembly/'Pipe #2 input at line 21@22-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #2 input at line 21@23'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #2 input at line 21@23'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0076
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0069
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0097
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'Pipe #2 input at line 21@22-1' assembly/'Pipe #2 input at line 21@22-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                              class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0046:  br.s       IL_0069
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0062:  stfld      string assembly/'Pipe #2 input at line 21@23'::current
+      IL_0067:  ldc.i4.1
+      IL_0068:  ret
+
+      IL_0069:  ldarg.0
+      IL_006a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_006f:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0074:  brtrue.s   IL_0048
+
+      IL_0076:  ldarg.0
+      IL_0077:  ldc.i4.3
+      IL_0078:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_007d:  ldarg.0
+      IL_007e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_0083:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_0088:  nop
+      IL_0089:  ldarg.0
+      IL_008a:  ldnull
+      IL_008b:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_0090:  ldarg.0
+      IL_0091:  ldc.i4.3
+      IL_0092:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0097:  ldarg.0
+      IL_0098:  ldnull
+      IL_0099:  stfld      string assembly/'Pipe #2 input at line 21@23'::current
+      IL_009e:  ldc.i4.0
+      IL_009f:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #2 input at line 21@23'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #2 input at line 21@23'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #2 input at line 21@23'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                                    int32,
+                                                                                                    string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'productFirstChars@32-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'productFirstChars@32-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Product>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'productFirstChars@32-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'productFirstChars@32-1' assembly/'productFirstChars@32-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname productFirstChars@33
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<char>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public char current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 char current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      char assembly/productFirstChars@33::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<char>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<char>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productFirstChars@33::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_007c
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_006f
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_009d
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'productFirstChars@32-1' assembly/'productFirstChars@32-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                              class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_0046:  br.s       IL_006f
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0062:  ldc.i4.0
+      IL_0063:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+      IL_0068:  stfld      char assembly/productFirstChars@33::current
+      IL_006d:  ldc.i4.1
+      IL_006e:  ret
+
+      IL_006f:  ldarg.0
+      IL_0070:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_0075:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_007a:  brtrue.s   IL_0048
+
+      IL_007c:  ldarg.0
+      IL_007d:  ldc.i4.3
+      IL_007e:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_0083:  ldarg.0
+      IL_0084:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_0089:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_008e:  nop
+      IL_008f:  ldarg.0
+      IL_0090:  ldnull
+      IL_0091:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_0096:  ldarg.0
+      IL_0097:  ldc.i4.3
+      IL_0098:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_009d:  ldarg.0
+      IL_009e:  ldc.i4.0
+      IL_009f:  stfld      char assembly/productFirstChars@33::current
+      IL_00a4:  ldc.i4.0
+      IL_00a5:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productFirstChars@33::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/productFirstChars@33::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/productFirstChars@33::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/productFirstChars@33::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      char assembly/productFirstChars@33::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productFirstChars@33::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance char get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      char assembly/productFirstChars@33::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<char> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/productFirstChars@33::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                           int32,
+                                                                                           char)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'customerFirstChars@38-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer>>
+  {
+    .field static assembly initonly class assembly/'customerFirstChars@38-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Customer>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'customerFirstChars@38-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'customerFirstChars@38-1' assembly/'customerFirstChars@38-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname customerFirstChars@39
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<char>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public char current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> 'enum',
+                                 int32 pc,
+                                 char current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      char assembly/customerFirstChars@39::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<char>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<char>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/customerFirstChars@39::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_007c
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_006f
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_009d
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'customerFirstChars@38-1' assembly/'customerFirstChars@38-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer>,class [Utils]Utils/Customer>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                 class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_0046:  br.s       IL_006f
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  callvirt   instance string [Utils]Utils/Customer::get_CompanyName()
+      IL_0062:  ldc.i4.0
+      IL_0063:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+      IL_0068:  stfld      char assembly/customerFirstChars@39::current
+      IL_006d:  ldc.i4.1
+      IL_006e:  ret
+
+      IL_006f:  ldarg.0
+      IL_0070:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_0075:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_007a:  brtrue.s   IL_0048
+
+      IL_007c:  ldarg.0
+      IL_007d:  ldc.i4.3
+      IL_007e:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_0083:  ldarg.0
+      IL_0084:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_0089:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>>(!!0)
+      IL_008e:  nop
+      IL_008f:  ldarg.0
+      IL_0090:  ldnull
+      IL_0091:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_0096:  ldarg.0
+      IL_0097:  ldc.i4.3
+      IL_0098:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_009d:  ldarg.0
+      IL_009e:  ldc.i4.0
+      IL_009f:  stfld      char assembly/customerFirstChars@39::current
+      IL_00a4:  ldc.i4.0
+      IL_00a5:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/customerFirstChars@39::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/customerFirstChars@39::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/customerFirstChars@39::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/customerFirstChars@39::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      char assembly/customerFirstChars@39::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/customerFirstChars@39::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance char get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      char assembly/customerFirstChars@39::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<char> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/customerFirstChars@39::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>,
+                                                                                            int32,
+                                                                                            char)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> factorsOf300@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> uniqueFactors@11
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@18
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> categoryNames@20
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@28
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<char> productFirstChars@30
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<char> customerFirstChars@36
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_factorsOf300() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::factorsOf300@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_uniqueFactors() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::uniqueFactors@11
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@18
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_categoryNames() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::categoryNames@20
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@28
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<char> get_productFirstChars() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::productFirstChars@30
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<char> get_customerFirstChars() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::customerFirstChars@36
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5)
+    IL_0000:  ldc.i4.2
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  ldc.i4.5
+    IL_0004:  ldc.i4.5
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::factorsOf300@9
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_002d:  stloc.1
+    IL_002e:  ldloc.1
+    IL_002f:  ldnull
+    IL_0030:  ldc.i4.0
+    IL_0031:  ldc.i4.0
+    IL_0032:  newobj     instance void assembly/'Pipe #1 input at line 12@13'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_0037:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_003c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Distinct<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_0041:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0046:  stloc.0
+    IL_0047:  ldloc.0
+    IL_0048:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_004d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::uniqueFactors@11
+    IL_0052:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0057:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@18
+    IL_005c:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0061:  stloc.3
+    IL_0062:  ldloc.3
+    IL_0063:  ldnull
+    IL_0064:  ldc.i4.0
+    IL_0065:  ldnull
+    IL_0066:  newobj     instance void assembly/'Pipe #2 input at line 21@23'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                                  int32,
+                                                                                                  string)
+    IL_006b:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0070:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Distinct<string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_0075:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_007a:  stloc.2
+    IL_007b:  ldloc.2
+    IL_007c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0081:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::categoryNames@20
+    IL_0086:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_008b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@28
+    IL_0090:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0095:  stloc.s    V_4
+    IL_0097:  ldnull
+    IL_0098:  ldc.i4.0
+    IL_0099:  ldc.i4.0
+    IL_009a:  newobj     instance void assembly/productFirstChars@33::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                         int32,
+                                                                                         char)
+    IL_009f:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::productFirstChars@30
+    IL_00a4:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00a9:  stloc.s    V_5
+    IL_00ab:  ldnull
+    IL_00ac:  ldc.i4.0
+    IL_00ad:  ldc.i4.0
+    IL_00ae:  newobj     instance void assembly/customerFirstChars@39::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>,
+                                                                                          int32,
+                                                                                          char)
+    IL_00b3:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::customerFirstChars@36
+    IL_00b8:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          factorsOf300()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_factorsOf300()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          uniqueFactors()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_uniqueFactors()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          categoryNames()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categoryNames()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<char>
+          productFirstChars()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::get_productFirstChars()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<char>
+          customerFirstChars()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::get_customerFirstChars()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOn.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOn.il.netcore.release.bsl
new file mode 100644
index 00000000000..303f6f4ed2f
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101SetOperators01.fs.RealInternalSignatureOn.il.netcore.release.bsl
@@ -0,0 +1,1439 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #1 input at line 12@13'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                 int32 pc,
+                                 int32 current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0,
+               int32 V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_006a
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_005d
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_008b
+
+      IL_0024:  nop
+      IL_0025:  nop
+      IL_0026:  ldarg.0
+      IL_0027:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_factorsOf300()
+      IL_002c:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+      IL_0031:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0036:  ldarg.0
+      IL_0037:  ldc.i4.1
+      IL_0038:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_003d:  br.s       IL_005d
+
+      IL_003f:  ldarg.0
+      IL_0040:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0045:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_004a:  stloc.0
+      IL_004b:  ldloc.0
+      IL_004c:  stloc.1
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.2
+      IL_004f:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0054:  ldarg.0
+      IL_0055:  ldloc.1
+      IL_0056:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+      IL_005b:  ldc.i4.1
+      IL_005c:  ret
+
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0063:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0068:  brtrue.s   IL_003f
+
+      IL_006a:  ldarg.0
+      IL_006b:  ldc.i4.3
+      IL_006c:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0071:  ldarg.0
+      IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+      IL_007c:  nop
+      IL_007d:  ldarg.0
+      IL_007e:  ldnull
+      IL_007f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+      IL_0084:  ldarg.0
+      IL_0085:  ldc.i4.3
+      IL_0086:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.0
+      IL_008d:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+      IL_0092:  ldc.i4.0
+      IL_0093:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> assembly/'Pipe #1 input at line 12@13'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance int32 get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #1 input at line 12@13'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/'Pipe #1 input at line 12@13'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                    int32,
+                                                                                                    int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 21@22-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 21@22-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Product>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 21@22-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 21@22-1' assembly/'Pipe #2 input at line 21@22-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #2 input at line 21@23'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #2 input at line 21@23'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0076
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0069
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0097
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'Pipe #2 input at line 21@22-1' assembly/'Pipe #2 input at line 21@22-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                              class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0046:  br.s       IL_0069
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  callvirt   instance string [Utils]Utils/Product::get_Category()
+      IL_0062:  stfld      string assembly/'Pipe #2 input at line 21@23'::current
+      IL_0067:  ldc.i4.1
+      IL_0068:  ret
+
+      IL_0069:  ldarg.0
+      IL_006a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_006f:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0074:  brtrue.s   IL_0048
+
+      IL_0076:  ldarg.0
+      IL_0077:  ldc.i4.3
+      IL_0078:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_007d:  ldarg.0
+      IL_007e:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_0083:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_0088:  nop
+      IL_0089:  ldarg.0
+      IL_008a:  ldnull
+      IL_008b:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+      IL_0090:  ldarg.0
+      IL_0091:  ldc.i4.3
+      IL_0092:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0097:  ldarg.0
+      IL_0098:  ldnull
+      IL_0099:  stfld      string assembly/'Pipe #2 input at line 21@23'::current
+      IL_009e:  ldc.i4.0
+      IL_009f:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/'Pipe #2 input at line 21@23'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #2 input at line 21@23'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #2 input at line 21@23'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #2 input at line 21@23'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #2 input at line 21@23'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                                    int32,
+                                                                                                    string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'productFirstChars@32-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>
+  {
+    .field static assembly initonly class assembly/'productFirstChars@32-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Product>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'productFirstChars@32-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'productFirstChars@32-1' assembly/'productFirstChars@32-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname productFirstChars@33
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<char>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public char current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> 'enum',
+                                 int32 pc,
+                                 char current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      char assembly/productFirstChars@33::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<char>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<char>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productFirstChars@33::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_007c
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_006f
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_009d
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'productFirstChars@32-1' assembly/'productFirstChars@32-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Product,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                              class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_0046:  br.s       IL_006f
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  callvirt   instance string [Utils]Utils/Product::get_ProductName()
+      IL_0062:  ldc.i4.0
+      IL_0063:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+      IL_0068:  stfld      char assembly/productFirstChars@33::current
+      IL_006d:  ldc.i4.1
+      IL_006e:  ret
+
+      IL_006f:  ldarg.0
+      IL_0070:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_0075:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_007a:  brtrue.s   IL_0048
+
+      IL_007c:  ldarg.0
+      IL_007d:  ldc.i4.3
+      IL_007e:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_0083:  ldarg.0
+      IL_0084:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_0089:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+      IL_008e:  nop
+      IL_008f:  ldarg.0
+      IL_0090:  ldnull
+      IL_0091:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+      IL_0096:  ldarg.0
+      IL_0097:  ldc.i4.3
+      IL_0098:  stfld      int32 assembly/productFirstChars@33::pc
+      IL_009d:  ldarg.0
+      IL_009e:  ldc.i4.0
+      IL_009f:  stfld      char assembly/productFirstChars@33::current
+      IL_00a4:  ldc.i4.0
+      IL_00a5:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productFirstChars@33::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/productFirstChars@33::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/productFirstChars@33::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product> assembly/productFirstChars@33::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/productFirstChars@33::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      char assembly/productFirstChars@33::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/productFirstChars@33::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance char get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      char assembly/productFirstChars@33::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<char> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/productFirstChars@33::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                           int32,
+                                                                                           char)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'customerFirstChars@38-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer>>
+  {
+    .field static assembly initonly class assembly/'customerFirstChars@38-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<class [Utils]Utils/Customer>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'customerFirstChars@38-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'customerFirstChars@38-1' assembly/'customerFirstChars@38-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname customerFirstChars@39
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<char>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public char current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> 'enum',
+                                 int32 pc,
+                                 char current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      char assembly/customerFirstChars@39::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<char>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<char>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/customerFirstChars@39::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_007c
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_006f
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_009d
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'customerFirstChars@38-1' assembly/'customerFirstChars@38-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<class [Utils]Utils/Customer,class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer>,class [Utils]Utils/Customer>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                                                                 class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_0046:  br.s       IL_006f
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  callvirt   instance string [Utils]Utils/Customer::get_CompanyName()
+      IL_0062:  ldc.i4.0
+      IL_0063:  callvirt   instance char [netstandard]System.String::get_Chars(int32)
+      IL_0068:  stfld      char assembly/customerFirstChars@39::current
+      IL_006d:  ldc.i4.1
+      IL_006e:  ret
+
+      IL_006f:  ldarg.0
+      IL_0070:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_0075:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_007a:  brtrue.s   IL_0048
+
+      IL_007c:  ldarg.0
+      IL_007d:  ldc.i4.3
+      IL_007e:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_0083:  ldarg.0
+      IL_0084:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_0089:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>>(!!0)
+      IL_008e:  nop
+      IL_008f:  ldarg.0
+      IL_0090:  ldnull
+      IL_0091:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+      IL_0096:  ldarg.0
+      IL_0097:  ldc.i4.3
+      IL_0098:  stfld      int32 assembly/customerFirstChars@39::pc
+      IL_009d:  ldarg.0
+      IL_009e:  ldc.i4.0
+      IL_009f:  stfld      char assembly/customerFirstChars@39::current
+      IL_00a4:  ldc.i4.0
+      IL_00a5:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/customerFirstChars@39::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/customerFirstChars@39::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/customerFirstChars@39::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer> assembly/customerFirstChars@39::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/customerFirstChars@39::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldc.i4.0
+        IL_005f:  stfld      char assembly/customerFirstChars@39::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/customerFirstChars@39::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance char get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      char assembly/customerFirstChars@39::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<char> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldc.i4.0
+      IL_0003:  newobj     instance void assembly/customerFirstChars@39::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>,
+                                                                                            int32,
+                                                                                            char)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> factorsOf300@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> uniqueFactors@11
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@18
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> categoryNames@20
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@28
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<char> productFirstChars@30
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<char> customerFirstChars@36
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_factorsOf300() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::factorsOf300@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_uniqueFactors() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::uniqueFactors@11
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@18
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_categoryNames() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::categoryNames@20
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@28
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<char> get_productFirstChars() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::productFirstChars@30
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<char> get_customerFirstChars() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::customerFirstChars@36
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5)
+    IL_0000:  ldc.i4.2
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  ldc.i4.5
+    IL_0004:  ldc.i4.5
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_000a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0014:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0023:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::factorsOf300@9
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_002d:  stloc.1
+    IL_002e:  ldloc.1
+    IL_002f:  ldnull
+    IL_0030:  ldc.i4.0
+    IL_0031:  ldc.i4.0
+    IL_0032:  newobj     instance void assembly/'Pipe #1 input at line 12@13'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                  int32,
+                                                                                                  int32)
+    IL_0037:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_003c:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Distinct<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_0041:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0046:  stloc.0
+    IL_0047:  ldloc.0
+    IL_0048:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_004d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::uniqueFactors@11
+    IL_0052:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0057:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@18
+    IL_005c:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0061:  stloc.3
+    IL_0062:  ldloc.3
+    IL_0063:  ldnull
+    IL_0064:  ldc.i4.0
+    IL_0065:  ldnull
+    IL_0066:  newobj     instance void assembly/'Pipe #2 input at line 21@23'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                                  int32,
+                                                                                                  string)
+    IL_006b:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::.ctor(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0070:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Distinct<string,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>)
+    IL_0075:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<string,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_007a:  stloc.2
+    IL_007b:  ldloc.2
+    IL_007c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToList<string>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0081:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::categoryNames@20
+    IL_0086:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_008b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@28
+    IL_0090:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_0095:  stloc.s    V_4
+    IL_0097:  ldnull
+    IL_0098:  ldc.i4.0
+    IL_0099:  ldc.i4.0
+    IL_009a:  newobj     instance void assembly/productFirstChars@33::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Product>,
+                                                                                         int32,
+                                                                                         char)
+    IL_009f:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::productFirstChars@30
+    IL_00a4:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00a9:  stloc.s    V_5
+    IL_00ab:  ldnull
+    IL_00ac:  ldc.i4.0
+    IL_00ad:  ldc.i4.0
+    IL_00ae:  newobj     instance void assembly/customerFirstChars@39::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<class [Utils]Utils/Customer>,
+                                                                                          int32,
+                                                                                          char)
+    IL_00b3:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::customerFirstChars@36
+    IL_00b8:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          factorsOf300()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_factorsOf300()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          uniqueFactors()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_uniqueFactors()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          categoryNames()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_categoryNames()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<char>
+          productFirstChars()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::get_productFirstChars()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<char>
+          customerFirstChars()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<char> assembly::get_customerFirstChars()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOff.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOff.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOff.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOff.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOff.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOff.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOn.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOn.il.net472.debug.bsl
new file mode 100644
index 00000000000..7cdc7a9d4e7
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOn.il.net472.debug.bsl
@@ -0,0 +1,1255 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@14'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@14'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@14'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<int32,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@15-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@15-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.5
+      IL_0002:  clt
+      IL_0004:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@15-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@15-1' assembly/'Pipe #1 input at line 13@15-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@16-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@16-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@16-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@16-2' assembly/'Pipe #1 input at line 13@16-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit soldOutProducts@24
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/soldOutProducts@24::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/soldOutProducts@24::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'soldOutProducts@25-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field static assembly initonly class assembly/'soldOutProducts@25-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'soldOutProducts@25-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'soldOutProducts@25-1' assembly/'soldOutProducts@25-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'soldOutProducts@26-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'soldOutProducts@26-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'soldOutProducts@26-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'soldOutProducts@26-2' assembly/'soldOutProducts@26-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit expensiveInStockProducts@32
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/expensiveInStockProducts@32::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/expensiveInStockProducts@32::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'expensiveInStockProducts@33-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field static assembly initonly class assembly/'expensiveInStockProducts@33-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ble.s      IL_0023
+
+      IL_0009:  ldarg.1
+      IL_000a:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_000f:  ldc.i4     0x12c
+      IL_0014:  ldc.i4.0
+      IL_0015:  ldc.i4.0
+      IL_0016:  ldc.i4.0
+      IL_0017:  ldc.i4.2
+      IL_0018:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                            int32,
+                                                                            int32,
+                                                                            bool,
+                                                                            uint8)
+      IL_001d:  call       bool [netstandard]System.Decimal::op_GreaterThan(valuetype [netstandard]System.Decimal,
+                                                                            valuetype [netstandard]System.Decimal)
+      IL_0022:  ret
+
+      IL_0023:  ldc.i4.0
+      IL_0024:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'expensiveInStockProducts@33-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'expensiveInStockProducts@33-1' assembly/'expensiveInStockProducts@33-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'expensiveInStockProducts@34-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'expensiveInStockProducts@34-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'expensiveInStockProducts@34-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'expensiveInStockProducts@34-2' assembly/'expensiveInStockProducts@34-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 41@42'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 41@42'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 41@42'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Customer,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 41@43-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 41@43-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Customer c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance string [Utils]Utils/Customer::get_Region()
+      IL_0006:  ldstr      "WA"
+      IL_000b:  call       bool [netstandard]System.String::Equals(string,
+                                                                   string)
+      IL_0010:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 41@43-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 41@43-1' assembly/'Pipe #2 input at line 41@43-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 41@44-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [Utils]Utils/Customer>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 41@44-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [Utils]Utils/Customer>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Customer Invoke(class [Utils]Utils/Customer c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 41@44-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 41@44-2' assembly/'Pipe #2 input at line 41@44-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 50@51-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 50@51-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<string> Invoke(string _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (string V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<string>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 50@51-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 50@51-1' assembly/'Pipe #3 input at line 50@51-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #3 input at line 50@52'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #3 input at line 50@52'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (string V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0071
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0064
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0092
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'Pipe #3 input at line 50@51-1' assembly/'Pipe #3 input at line 50@51-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>,string>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                      class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0046:  br.s       IL_0064
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  stfld      string assembly/'Pipe #3 input at line 50@52'::current
+      IL_0062:  ldc.i4.1
+      IL_0063:  ret
+
+      IL_0064:  ldarg.0
+      IL_0065:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_006a:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_006f:  brtrue.s   IL_0048
+
+      IL_0071:  ldarg.0
+      IL_0072:  ldc.i4.3
+      IL_0073:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0078:  ldarg.0
+      IL_0079:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_007e:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_0083:  nop
+      IL_0084:  ldarg.0
+      IL_0085:  ldnull
+      IL_0086:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.3
+      IL_008d:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0092:  ldarg.0
+      IL_0093:  ldnull
+      IL_0094:  stfld      string assembly/'Pipe #3 input at line 50@52'::current
+      IL_0099:  ldc.i4.0
+      IL_009a:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #3 input at line 50@52'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #3 input at line 50@52'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #3 input at line 50@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                             int32,
+                                                                                             string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 stage #1 at line 54@54'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<int32,string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 stage #1 at line 54@54' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<int32,string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> 
+            Invoke(int32 i,
+                   string d) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  nop
+      IL_0001:  ldarg.2
+      IL_0002:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0007:  ldarg.1
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  ldarg.2
+      IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<!0> class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>::Some(!0)
+      IL_0010:  ret
+
+      IL_0011:  ldnull
+      IL_0012:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 stage #1 at line 54@54'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 stage #1 at line 54@54' assembly/'Pipe #3 stage #1 at line 54@54'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit shortDigits@55
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>
+  {
+    .field static assembly initonly class assembly/shortDigits@55 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Identity<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>(!!0)
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/shortDigits@55::.ctor()
+      IL_0005:  stsfld     class assembly/shortDigits@55 assembly/shortDigits@55::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> lowNums@12
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@20
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> soldOutProducts@22
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> expensiveInStockProducts@30
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@38
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Customer[] waCustomers@40
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> digits@48
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<string> shortDigits@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_lowNums() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::lowNums@12
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@20
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> get_soldOutProducts() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::soldOutProducts@22
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> get_expensiveInStockProducts() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::expensiveInStockProducts@30
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@38
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Customer[] get_waCustomers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Customer[] assembly::waCustomers@40
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_digits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@48
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<string> get_shortDigits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::shortDigits@49
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>> V_8)
+    IL_0000:  ldc.i4.5
+    IL_0001:  ldc.i4.4
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.3
+    IL_0004:  ldc.i4.s   9
+    IL_0006:  ldc.i4.8
+    IL_0007:  ldc.i4.6
+    IL_0008:  ldc.i4.7
+    IL_0009:  ldc.i4.2
+    IL_000a:  ldc.i4.0
+    IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0010:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0015:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0024:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0029:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0033:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_003d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0042:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@9
+    IL_0047:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_004c:  stloc.1
+    IL_004d:  ldloc.1
+    IL_004e:  ldloc.1
+    IL_004f:  ldloc.1
+    IL_0050:  ldloc.1
+    IL_0051:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+    IL_0056:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_005b:  ldloc.1
+    IL_005c:  newobj     instance void assembly/'Pipe #1 input at line 13@14'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0061:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,int32,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0066:  ldsfld     class assembly/'Pipe #1 input at line 13@15-1' assembly/'Pipe #1 input at line 13@15-1'::@_instance
+    IL_006b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0070:  ldsfld     class assembly/'Pipe #1 input at line 13@16-2' assembly/'Pipe #1 input at line 13@16-2'::@_instance
+    IL_0075:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<int32,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_007a:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_007f:  stloc.0
+    IL_0080:  ldloc.0
+    IL_0081:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::OfSeq<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0086:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::lowNums@12
+    IL_008b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0090:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@20
+    IL_0095:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_009a:  stloc.2
+    IL_009b:  ldloc.2
+    IL_009c:  ldloc.2
+    IL_009d:  ldloc.2
+    IL_009e:  ldloc.2
+    IL_009f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_00a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00a9:  ldloc.2
+    IL_00aa:  newobj     instance void assembly/soldOutProducts@24::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00af:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00b4:  ldsfld     class assembly/'soldOutProducts@25-1' assembly/'soldOutProducts@25-1'::@_instance
+    IL_00b9:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00be:  ldsfld     class assembly/'soldOutProducts@26-2' assembly/'soldOutProducts@26-2'::@_instance
+    IL_00c3:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00c8:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00cd:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::soldOutProducts@22
+    IL_00d2:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00d7:  stloc.3
+    IL_00d8:  ldloc.3
+    IL_00d9:  ldloc.3
+    IL_00da:  ldloc.3
+    IL_00db:  ldloc.3
+    IL_00dc:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_00e1:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00e6:  ldloc.3
+    IL_00e7:  newobj     instance void assembly/expensiveInStockProducts@32::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00ec:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00f1:  ldsfld     class assembly/'expensiveInStockProducts@33-1' assembly/'expensiveInStockProducts@33-1'::@_instance
+    IL_00f6:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00fb:  ldsfld     class assembly/'expensiveInStockProducts@34-2' assembly/'expensiveInStockProducts@34-2'::@_instance
+    IL_0100:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0105:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_010a:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::expensiveInStockProducts@30
+    IL_010f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_0114:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@38
+    IL_0119:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_011e:  stloc.s    V_5
+    IL_0120:  ldloc.s    V_5
+    IL_0122:  ldloc.s    V_5
+    IL_0124:  ldloc.s    V_5
+    IL_0126:  ldloc.s    V_5
+    IL_0128:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_012d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0132:  ldloc.s    V_5
+    IL_0134:  newobj     instance void assembly/'Pipe #2 input at line 41@42'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0139:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Customer,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_013e:  ldsfld     class assembly/'Pipe #2 input at line 41@43-1' assembly/'Pipe #2 input at line 41@43-1'::@_instance
+    IL_0143:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0148:  ldsfld     class assembly/'Pipe #2 input at line 41@44-2' assembly/'Pipe #2 input at line 41@44-2'::@_instance
+    IL_014d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Customer>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0152:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0157:  stloc.s    V_4
+    IL_0159:  ldloc.s    V_4
+    IL_015b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0160:  stsfld     class [Utils]Utils/Customer[] assembly::waCustomers@40
+    IL_0165:  ldstr      "zero"
+    IL_016a:  ldstr      "one"
+    IL_016f:  ldstr      "two"
+    IL_0174:  ldstr      "three"
+    IL_0179:  ldstr      "four"
+    IL_017e:  ldstr      "five"
+    IL_0183:  ldstr      "six"
+    IL_0188:  ldstr      "seven"
+    IL_018d:  ldstr      "eight"
+    IL_0192:  ldstr      "nine"
+    IL_0197:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_019c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01a1:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01a6:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01ab:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01b0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01b5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01ba:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01bf:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01c4:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01c9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01ce:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@48
+    IL_01d3:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_01d8:  stloc.s    V_7
+    IL_01da:  ldnull
+    IL_01db:  ldc.i4.0
+    IL_01dc:  ldnull
+    IL_01dd:  newobj     instance void assembly/'Pipe #3 input at line 50@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                           int32,
+                                                                                           string)
+    IL_01e2:  stloc.s    V_6
+    IL_01e4:  ldsfld     class assembly/'Pipe #3 stage #1 at line 54@54' assembly/'Pipe #3 stage #1 at line 54@54'::@_instance
+    IL_01e9:  ldloc.s    V_6
+    IL_01eb:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::MapIndexed<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>>,
+                                                                                                                                                                                                                               class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01f0:  stloc.s    V_8
+    IL_01f2:  ldsfld     class assembly/shortDigits@55 assembly/shortDigits@55::@_instance
+    IL_01f7:  ldloc.s    V_8
+    IL_01f9:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Choose<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>,string>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<!!1>>,
+                                                                                                                                                                                                                           class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01fe:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::shortDigits@49
+    IL_0203:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          lowNums()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_lowNums()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>
+          soldOutProducts()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::get_soldOutProducts()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>
+          expensiveInStockProducts()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::get_expensiveInStockProducts()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [Utils]Utils/Customer[]
+          waCustomers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Customer[] assembly::get_waCustomers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          digits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<string>
+          shortDigits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::get_shortDigits()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOn.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOn.il.net472.release.bsl
new file mode 100644
index 00000000000..7cdc7a9d4e7
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOn.il.net472.release.bsl
@@ -0,0 +1,1255 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@14'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@14'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@14'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<int32,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@15-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@15-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.5
+      IL_0002:  clt
+      IL_0004:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@15-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@15-1' assembly/'Pipe #1 input at line 13@15-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@16-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@16-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@16-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@16-2' assembly/'Pipe #1 input at line 13@16-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit soldOutProducts@24
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/soldOutProducts@24::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/soldOutProducts@24::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'soldOutProducts@25-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field static assembly initonly class assembly/'soldOutProducts@25-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'soldOutProducts@25-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'soldOutProducts@25-1' assembly/'soldOutProducts@25-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'soldOutProducts@26-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'soldOutProducts@26-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'soldOutProducts@26-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'soldOutProducts@26-2' assembly/'soldOutProducts@26-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit expensiveInStockProducts@32
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/expensiveInStockProducts@32::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/expensiveInStockProducts@32::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'expensiveInStockProducts@33-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field static assembly initonly class assembly/'expensiveInStockProducts@33-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ble.s      IL_0023
+
+      IL_0009:  ldarg.1
+      IL_000a:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_000f:  ldc.i4     0x12c
+      IL_0014:  ldc.i4.0
+      IL_0015:  ldc.i4.0
+      IL_0016:  ldc.i4.0
+      IL_0017:  ldc.i4.2
+      IL_0018:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                            int32,
+                                                                            int32,
+                                                                            bool,
+                                                                            uint8)
+      IL_001d:  call       bool [netstandard]System.Decimal::op_GreaterThan(valuetype [netstandard]System.Decimal,
+                                                                            valuetype [netstandard]System.Decimal)
+      IL_0022:  ret
+
+      IL_0023:  ldc.i4.0
+      IL_0024:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'expensiveInStockProducts@33-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'expensiveInStockProducts@33-1' assembly/'expensiveInStockProducts@33-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'expensiveInStockProducts@34-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'expensiveInStockProducts@34-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'expensiveInStockProducts@34-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'expensiveInStockProducts@34-2' assembly/'expensiveInStockProducts@34-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 41@42'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 41@42'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 41@42'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Customer,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 41@43-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 41@43-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Customer c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance string [Utils]Utils/Customer::get_Region()
+      IL_0006:  ldstr      "WA"
+      IL_000b:  call       bool [netstandard]System.String::Equals(string,
+                                                                   string)
+      IL_0010:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 41@43-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 41@43-1' assembly/'Pipe #2 input at line 41@43-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 41@44-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [Utils]Utils/Customer>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 41@44-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [Utils]Utils/Customer>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Customer Invoke(class [Utils]Utils/Customer c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 41@44-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 41@44-2' assembly/'Pipe #2 input at line 41@44-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 50@51-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 50@51-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<string> Invoke(string _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (string V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<string>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 50@51-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 50@51-1' assembly/'Pipe #3 input at line 50@51-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #3 input at line 50@52'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #3 input at line 50@52'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (string V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0071
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0064
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0092
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'Pipe #3 input at line 50@51-1' assembly/'Pipe #3 input at line 50@51-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>,string>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                      class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0046:  br.s       IL_0064
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  stfld      string assembly/'Pipe #3 input at line 50@52'::current
+      IL_0062:  ldc.i4.1
+      IL_0063:  ret
+
+      IL_0064:  ldarg.0
+      IL_0065:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_006a:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_006f:  brtrue.s   IL_0048
+
+      IL_0071:  ldarg.0
+      IL_0072:  ldc.i4.3
+      IL_0073:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0078:  ldarg.0
+      IL_0079:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_007e:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_0083:  nop
+      IL_0084:  ldarg.0
+      IL_0085:  ldnull
+      IL_0086:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.3
+      IL_008d:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0092:  ldarg.0
+      IL_0093:  ldnull
+      IL_0094:  stfld      string assembly/'Pipe #3 input at line 50@52'::current
+      IL_0099:  ldc.i4.0
+      IL_009a:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #3 input at line 50@52'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #3 input at line 50@52'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #3 input at line 50@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                             int32,
+                                                                                             string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 stage #1 at line 54@54'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<int32,string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 stage #1 at line 54@54' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<int32,string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> 
+            Invoke(int32 i,
+                   string d) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  nop
+      IL_0001:  ldarg.2
+      IL_0002:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0007:  ldarg.1
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  ldarg.2
+      IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<!0> class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>::Some(!0)
+      IL_0010:  ret
+
+      IL_0011:  ldnull
+      IL_0012:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 stage #1 at line 54@54'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 stage #1 at line 54@54' assembly/'Pipe #3 stage #1 at line 54@54'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit shortDigits@55
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>
+  {
+    .field static assembly initonly class assembly/shortDigits@55 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Identity<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>(!!0)
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/shortDigits@55::.ctor()
+      IL_0005:  stsfld     class assembly/shortDigits@55 assembly/shortDigits@55::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> lowNums@12
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@20
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> soldOutProducts@22
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> expensiveInStockProducts@30
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@38
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Customer[] waCustomers@40
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> digits@48
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<string> shortDigits@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_lowNums() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::lowNums@12
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@20
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> get_soldOutProducts() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::soldOutProducts@22
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> get_expensiveInStockProducts() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::expensiveInStockProducts@30
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@38
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Customer[] get_waCustomers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Customer[] assembly::waCustomers@40
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_digits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@48
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<string> get_shortDigits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::shortDigits@49
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>> V_8)
+    IL_0000:  ldc.i4.5
+    IL_0001:  ldc.i4.4
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.3
+    IL_0004:  ldc.i4.s   9
+    IL_0006:  ldc.i4.8
+    IL_0007:  ldc.i4.6
+    IL_0008:  ldc.i4.7
+    IL_0009:  ldc.i4.2
+    IL_000a:  ldc.i4.0
+    IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0010:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0015:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0024:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0029:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0033:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_003d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0042:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@9
+    IL_0047:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_004c:  stloc.1
+    IL_004d:  ldloc.1
+    IL_004e:  ldloc.1
+    IL_004f:  ldloc.1
+    IL_0050:  ldloc.1
+    IL_0051:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+    IL_0056:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_005b:  ldloc.1
+    IL_005c:  newobj     instance void assembly/'Pipe #1 input at line 13@14'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0061:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,int32,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0066:  ldsfld     class assembly/'Pipe #1 input at line 13@15-1' assembly/'Pipe #1 input at line 13@15-1'::@_instance
+    IL_006b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                               class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0070:  ldsfld     class assembly/'Pipe #1 input at line 13@16-2' assembly/'Pipe #1 input at line 13@16-2'::@_instance
+    IL_0075:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<int32,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_007a:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_007f:  stloc.0
+    IL_0080:  ldloc.0
+    IL_0081:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::OfSeq<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0086:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::lowNums@12
+    IL_008b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0090:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@20
+    IL_0095:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_009a:  stloc.2
+    IL_009b:  ldloc.2
+    IL_009c:  ldloc.2
+    IL_009d:  ldloc.2
+    IL_009e:  ldloc.2
+    IL_009f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_00a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00a9:  ldloc.2
+    IL_00aa:  newobj     instance void assembly/soldOutProducts@24::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00af:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00b4:  ldsfld     class assembly/'soldOutProducts@25-1' assembly/'soldOutProducts@25-1'::@_instance
+    IL_00b9:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00be:  ldsfld     class assembly/'soldOutProducts@26-2' assembly/'soldOutProducts@26-2'::@_instance
+    IL_00c3:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00c8:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00cd:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::soldOutProducts@22
+    IL_00d2:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00d7:  stloc.3
+    IL_00d8:  ldloc.3
+    IL_00d9:  ldloc.3
+    IL_00da:  ldloc.3
+    IL_00db:  ldloc.3
+    IL_00dc:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_00e1:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00e6:  ldloc.3
+    IL_00e7:  newobj     instance void assembly/expensiveInStockProducts@32::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00ec:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00f1:  ldsfld     class assembly/'expensiveInStockProducts@33-1' assembly/'expensiveInStockProducts@33-1'::@_instance
+    IL_00f6:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00fb:  ldsfld     class assembly/'expensiveInStockProducts@34-2' assembly/'expensiveInStockProducts@34-2'::@_instance
+    IL_0100:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0105:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_010a:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::expensiveInStockProducts@30
+    IL_010f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_0114:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@38
+    IL_0119:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_011e:  stloc.s    V_5
+    IL_0120:  ldloc.s    V_5
+    IL_0122:  ldloc.s    V_5
+    IL_0124:  ldloc.s    V_5
+    IL_0126:  ldloc.s    V_5
+    IL_0128:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_012d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0132:  ldloc.s    V_5
+    IL_0134:  newobj     instance void assembly/'Pipe #2 input at line 41@42'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0139:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Customer,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_013e:  ldsfld     class assembly/'Pipe #2 input at line 41@43-1' assembly/'Pipe #2 input at line 41@43-1'::@_instance
+    IL_0143:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0148:  ldsfld     class assembly/'Pipe #2 input at line 41@44-2' assembly/'Pipe #2 input at line 41@44-2'::@_instance
+    IL_014d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Customer>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                  class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0152:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0157:  stloc.s    V_4
+    IL_0159:  ldloc.s    V_4
+    IL_015b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0160:  stsfld     class [Utils]Utils/Customer[] assembly::waCustomers@40
+    IL_0165:  ldstr      "zero"
+    IL_016a:  ldstr      "one"
+    IL_016f:  ldstr      "two"
+    IL_0174:  ldstr      "three"
+    IL_0179:  ldstr      "four"
+    IL_017e:  ldstr      "five"
+    IL_0183:  ldstr      "six"
+    IL_0188:  ldstr      "seven"
+    IL_018d:  ldstr      "eight"
+    IL_0192:  ldstr      "nine"
+    IL_0197:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_019c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01a1:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01a6:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01ab:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01b0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01b5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01ba:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01bf:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01c4:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01c9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01ce:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@48
+    IL_01d3:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_01d8:  stloc.s    V_7
+    IL_01da:  ldnull
+    IL_01db:  ldc.i4.0
+    IL_01dc:  ldnull
+    IL_01dd:  newobj     instance void assembly/'Pipe #3 input at line 50@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                           int32,
+                                                                                           string)
+    IL_01e2:  stloc.s    V_6
+    IL_01e4:  ldsfld     class assembly/'Pipe #3 stage #1 at line 54@54' assembly/'Pipe #3 stage #1 at line 54@54'::@_instance
+    IL_01e9:  ldloc.s    V_6
+    IL_01eb:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::MapIndexed<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>>,
+                                                                                                                                                                                                                               class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01f0:  stloc.s    V_8
+    IL_01f2:  ldsfld     class assembly/shortDigits@55 assembly/shortDigits@55::@_instance
+    IL_01f7:  ldloc.s    V_8
+    IL_01f9:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Choose<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>,string>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<!!1>>,
+                                                                                                                                                                                                                           class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01fe:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::shortDigits@49
+    IL_0203:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          lowNums()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_lowNums()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>
+          soldOutProducts()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::get_soldOutProducts()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>
+          expensiveInStockProducts()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::get_expensiveInStockProducts()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [Utils]Utils/Customer[]
+          waCustomers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Customer[] assembly::get_waCustomers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          digits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<string>
+          shortDigits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::get_shortDigits()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOn.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
new file mode 100644
index 00000000000..f0e638e9a04
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
@@ -0,0 +1,1255 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@14'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@14'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@14'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<int32,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@15-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@15-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.5
+      IL_0002:  clt
+      IL_0004:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@15-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@15-1' assembly/'Pipe #1 input at line 13@15-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@16-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@16-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@16-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@16-2' assembly/'Pipe #1 input at line 13@16-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit soldOutProducts@24
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/soldOutProducts@24::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/soldOutProducts@24::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'soldOutProducts@25-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field static assembly initonly class assembly/'soldOutProducts@25-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'soldOutProducts@25-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'soldOutProducts@25-1' assembly/'soldOutProducts@25-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'soldOutProducts@26-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'soldOutProducts@26-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'soldOutProducts@26-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'soldOutProducts@26-2' assembly/'soldOutProducts@26-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit expensiveInStockProducts@32
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/expensiveInStockProducts@32::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/expensiveInStockProducts@32::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'expensiveInStockProducts@33-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field static assembly initonly class assembly/'expensiveInStockProducts@33-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ble.s      IL_0023
+
+      IL_0009:  ldarg.1
+      IL_000a:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_000f:  ldc.i4     0x12c
+      IL_0014:  ldc.i4.0
+      IL_0015:  ldc.i4.0
+      IL_0016:  ldc.i4.0
+      IL_0017:  ldc.i4.2
+      IL_0018:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                            int32,
+                                                                            int32,
+                                                                            bool,
+                                                                            uint8)
+      IL_001d:  call       bool [netstandard]System.Decimal::op_GreaterThan(valuetype [netstandard]System.Decimal,
+                                                                            valuetype [netstandard]System.Decimal)
+      IL_0022:  ret
+
+      IL_0023:  ldc.i4.0
+      IL_0024:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'expensiveInStockProducts@33-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'expensiveInStockProducts@33-1' assembly/'expensiveInStockProducts@33-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'expensiveInStockProducts@34-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'expensiveInStockProducts@34-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'expensiveInStockProducts@34-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'expensiveInStockProducts@34-2' assembly/'expensiveInStockProducts@34-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 41@42'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 41@42'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 41@42'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Customer,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 41@43-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 41@43-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Customer c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance string [Utils]Utils/Customer::get_Region()
+      IL_0006:  ldstr      "WA"
+      IL_000b:  call       bool [netstandard]System.String::Equals(string,
+                                                                   string)
+      IL_0010:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 41@43-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 41@43-1' assembly/'Pipe #2 input at line 41@43-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 41@44-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [Utils]Utils/Customer>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 41@44-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [Utils]Utils/Customer>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Customer Invoke(class [Utils]Utils/Customer c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 41@44-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 41@44-2' assembly/'Pipe #2 input at line 41@44-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 50@51-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 50@51-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<string> Invoke(string _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (string V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<string>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 50@51-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 50@51-1' assembly/'Pipe #3 input at line 50@51-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #3 input at line 50@52'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #3 input at line 50@52'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (string V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0071
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0064
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0092
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'Pipe #3 input at line 50@51-1' assembly/'Pipe #3 input at line 50@51-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>,string>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                  class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0046:  br.s       IL_0064
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  stfld      string assembly/'Pipe #3 input at line 50@52'::current
+      IL_0062:  ldc.i4.1
+      IL_0063:  ret
+
+      IL_0064:  ldarg.0
+      IL_0065:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_006a:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_006f:  brtrue.s   IL_0048
+
+      IL_0071:  ldarg.0
+      IL_0072:  ldc.i4.3
+      IL_0073:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0078:  ldarg.0
+      IL_0079:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_007e:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_0083:  nop
+      IL_0084:  ldarg.0
+      IL_0085:  ldnull
+      IL_0086:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.3
+      IL_008d:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0092:  ldarg.0
+      IL_0093:  ldnull
+      IL_0094:  stfld      string assembly/'Pipe #3 input at line 50@52'::current
+      IL_0099:  ldc.i4.0
+      IL_009a:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #3 input at line 50@52'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #3 input at line 50@52'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #3 input at line 50@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                             int32,
+                                                                                             string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 stage #1 at line 54@54'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<int32,string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 stage #1 at line 54@54' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<int32,string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> 
+            Invoke(int32 i,
+                   string d) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  nop
+      IL_0001:  ldarg.2
+      IL_0002:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0007:  ldarg.1
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  ldarg.2
+      IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<!0> class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>::Some(!0)
+      IL_0010:  ret
+
+      IL_0011:  ldnull
+      IL_0012:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 stage #1 at line 54@54'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 stage #1 at line 54@54' assembly/'Pipe #3 stage #1 at line 54@54'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit shortDigits@55
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>
+  {
+    .field static assembly initonly class assembly/shortDigits@55 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Identity<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>(!!0)
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/shortDigits@55::.ctor()
+      IL_0005:  stsfld     class assembly/shortDigits@55 assembly/shortDigits@55::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> lowNums@12
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@20
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> soldOutProducts@22
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> expensiveInStockProducts@30
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@38
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Customer[] waCustomers@40
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> digits@48
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<string> shortDigits@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_lowNums() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::lowNums@12
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@20
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> get_soldOutProducts() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::soldOutProducts@22
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> get_expensiveInStockProducts() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::expensiveInStockProducts@30
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@38
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Customer[] get_waCustomers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Customer[] assembly::waCustomers@40
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_digits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@48
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<string> get_shortDigits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::shortDigits@49
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>> V_8)
+    IL_0000:  ldc.i4.5
+    IL_0001:  ldc.i4.4
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.3
+    IL_0004:  ldc.i4.s   9
+    IL_0006:  ldc.i4.8
+    IL_0007:  ldc.i4.6
+    IL_0008:  ldc.i4.7
+    IL_0009:  ldc.i4.2
+    IL_000a:  ldc.i4.0
+    IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0010:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0015:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0024:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0029:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0033:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_003d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0042:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@9
+    IL_0047:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_004c:  stloc.1
+    IL_004d:  ldloc.1
+    IL_004e:  ldloc.1
+    IL_004f:  ldloc.1
+    IL_0050:  ldloc.1
+    IL_0051:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+    IL_0056:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_005b:  ldloc.1
+    IL_005c:  newobj     instance void assembly/'Pipe #1 input at line 13@14'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0061:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,int32,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0066:  ldsfld     class assembly/'Pipe #1 input at line 13@15-1' assembly/'Pipe #1 input at line 13@15-1'::@_instance
+    IL_006b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0070:  ldsfld     class assembly/'Pipe #1 input at line 13@16-2' assembly/'Pipe #1 input at line 13@16-2'::@_instance
+    IL_0075:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<int32,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_007a:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_007f:  stloc.0
+    IL_0080:  ldloc.0
+    IL_0081:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::OfSeq<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0086:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::lowNums@12
+    IL_008b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0090:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@20
+    IL_0095:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_009a:  stloc.2
+    IL_009b:  ldloc.2
+    IL_009c:  ldloc.2
+    IL_009d:  ldloc.2
+    IL_009e:  ldloc.2
+    IL_009f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_00a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00a9:  ldloc.2
+    IL_00aa:  newobj     instance void assembly/soldOutProducts@24::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00af:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00b4:  ldsfld     class assembly/'soldOutProducts@25-1' assembly/'soldOutProducts@25-1'::@_instance
+    IL_00b9:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00be:  ldsfld     class assembly/'soldOutProducts@26-2' assembly/'soldOutProducts@26-2'::@_instance
+    IL_00c3:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00c8:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00cd:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::soldOutProducts@22
+    IL_00d2:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00d7:  stloc.3
+    IL_00d8:  ldloc.3
+    IL_00d9:  ldloc.3
+    IL_00da:  ldloc.3
+    IL_00db:  ldloc.3
+    IL_00dc:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_00e1:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00e6:  ldloc.3
+    IL_00e7:  newobj     instance void assembly/expensiveInStockProducts@32::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00ec:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00f1:  ldsfld     class assembly/'expensiveInStockProducts@33-1' assembly/'expensiveInStockProducts@33-1'::@_instance
+    IL_00f6:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00fb:  ldsfld     class assembly/'expensiveInStockProducts@34-2' assembly/'expensiveInStockProducts@34-2'::@_instance
+    IL_0100:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0105:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_010a:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::expensiveInStockProducts@30
+    IL_010f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_0114:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@38
+    IL_0119:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_011e:  stloc.s    V_5
+    IL_0120:  ldloc.s    V_5
+    IL_0122:  ldloc.s    V_5
+    IL_0124:  ldloc.s    V_5
+    IL_0126:  ldloc.s    V_5
+    IL_0128:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_012d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0132:  ldloc.s    V_5
+    IL_0134:  newobj     instance void assembly/'Pipe #2 input at line 41@42'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0139:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Customer,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_013e:  ldsfld     class assembly/'Pipe #2 input at line 41@43-1' assembly/'Pipe #2 input at line 41@43-1'::@_instance
+    IL_0143:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0148:  ldsfld     class assembly/'Pipe #2 input at line 41@44-2' assembly/'Pipe #2 input at line 41@44-2'::@_instance
+    IL_014d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Customer>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0152:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0157:  stloc.s    V_4
+    IL_0159:  ldloc.s    V_4
+    IL_015b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0160:  stsfld     class [Utils]Utils/Customer[] assembly::waCustomers@40
+    IL_0165:  ldstr      "zero"
+    IL_016a:  ldstr      "one"
+    IL_016f:  ldstr      "two"
+    IL_0174:  ldstr      "three"
+    IL_0179:  ldstr      "four"
+    IL_017e:  ldstr      "five"
+    IL_0183:  ldstr      "six"
+    IL_0188:  ldstr      "seven"
+    IL_018d:  ldstr      "eight"
+    IL_0192:  ldstr      "nine"
+    IL_0197:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_019c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01a1:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01a6:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01ab:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01b0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01b5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01ba:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01bf:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01c4:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01c9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01ce:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@48
+    IL_01d3:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_01d8:  stloc.s    V_7
+    IL_01da:  ldnull
+    IL_01db:  ldc.i4.0
+    IL_01dc:  ldnull
+    IL_01dd:  newobj     instance void assembly/'Pipe #3 input at line 50@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                           int32,
+                                                                                           string)
+    IL_01e2:  stloc.s    V_6
+    IL_01e4:  ldsfld     class assembly/'Pipe #3 stage #1 at line 54@54' assembly/'Pipe #3 stage #1 at line 54@54'::@_instance
+    IL_01e9:  ldloc.s    V_6
+    IL_01eb:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::MapIndexed<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>>,
+                                                                                                                                                                                                                                     class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01f0:  stloc.s    V_8
+    IL_01f2:  ldsfld     class assembly/shortDigits@55 assembly/shortDigits@55::@_instance
+    IL_01f7:  ldloc.s    V_8
+    IL_01f9:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Choose<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>,string>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<!!1>>,
+                                                                                                                                                                                                                                 class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01fe:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::shortDigits@49
+    IL_0203:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          lowNums()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_lowNums()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>
+          soldOutProducts()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::get_soldOutProducts()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>
+          expensiveInStockProducts()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::get_expensiveInStockProducts()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [Utils]Utils/Customer[]
+          waCustomers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Customer[] assembly::get_waCustomers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          digits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<string>
+          shortDigits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::get_shortDigits()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOn.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOn.il.netcore.release.bsl
new file mode 100644
index 00000000000..f0e638e9a04
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/Linq101Where01.fs.RealInternalSignatureOn.il.netcore.release.bsl
@@ -0,0 +1,1255 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern Utils
+{
+  .ver 0:0:0:0
+}
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@14'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@14'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,object> Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #1 input at line 13@14'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<int32,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@15-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@15-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldc.i4.5
+      IL_0002:  clt
+      IL_0004:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@15-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@15-1' assembly/'Pipe #1 input at line 13@15-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #1 input at line 13@16-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>
+  {
+    .field static assembly initonly class assembly/'Pipe #1 input at line 13@16-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,int32>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance int32 Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #1 input at line 13@16-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #1 input at line 13@16-2' assembly/'Pipe #1 input at line 13@16-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit soldOutProducts@24
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/soldOutProducts@24::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/soldOutProducts@24::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'soldOutProducts@25-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field static assembly initonly class assembly/'soldOutProducts@25-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ceq
+      IL_0009:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'soldOutProducts@25-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'soldOutProducts@25-1' assembly/'soldOutProducts@25-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'soldOutProducts@26-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'soldOutProducts@26-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'soldOutProducts@26-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'soldOutProducts@26-2' assembly/'soldOutProducts@26-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit expensiveInStockProducts@32
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/expensiveInStockProducts@32::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,object> Invoke(class [Utils]Utils/Product _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Product V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/expensiveInStockProducts@32::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Product,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'expensiveInStockProducts@33-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>
+  {
+    .field static assembly initonly class assembly/'expensiveInStockProducts@33-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance int32 [Utils]Utils/Product::get_UnitsInStock()
+      IL_0006:  ldc.i4.0
+      IL_0007:  ble.s      IL_0023
+
+      IL_0009:  ldarg.1
+      IL_000a:  callvirt   instance valuetype [runtime]System.Decimal [Utils]Utils/Product::get_UnitPrice()
+      IL_000f:  ldc.i4     0x12c
+      IL_0014:  ldc.i4.0
+      IL_0015:  ldc.i4.0
+      IL_0016:  ldc.i4.0
+      IL_0017:  ldc.i4.2
+      IL_0018:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                            int32,
+                                                                            int32,
+                                                                            bool,
+                                                                            uint8)
+      IL_001d:  call       bool [netstandard]System.Decimal::op_GreaterThan(valuetype [netstandard]System.Decimal,
+                                                                            valuetype [netstandard]System.Decimal)
+      IL_0022:  ret
+
+      IL_0023:  ldc.i4.0
+      IL_0024:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'expensiveInStockProducts@33-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'expensiveInStockProducts@33-1' assembly/'expensiveInStockProducts@33-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'expensiveInStockProducts@34-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>
+  {
+    .field static assembly initonly class assembly/'expensiveInStockProducts@34-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Product,class [Utils]Utils/Product>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Product Invoke(class [Utils]Utils/Product p) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'expensiveInStockProducts@34-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'expensiveInStockProducts@34-2' assembly/'expensiveInStockProducts@34-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 41@42'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder builder@) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 41@42'::builder@
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,object> Invoke(class [Utils]Utils/Customer _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [Utils]Utils/Customer V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldarg.0
+      IL_0003:  ldfld      class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder assembly/'Pipe #2 input at line 41@42'::builder@
+      IL_0008:  ldloc.0
+      IL_0009:  tail.
+      IL_000b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Yield<class [Utils]Utils/Customer,object>(!!0)
+      IL_0010:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 41@43-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,bool>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 41@43-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(class [Utils]Utils/Customer c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  callvirt   instance string [Utils]Utils/Customer::get_Region()
+      IL_0006:  ldstr      "WA"
+      IL_000b:  call       bool [netstandard]System.String::Equals(string,
+                                                                   string)
+      IL_0010:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 41@43-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 41@43-1' assembly/'Pipe #2 input at line 41@43-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #2 input at line 41@44-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [Utils]Utils/Customer>
+  {
+    .field static assembly initonly class assembly/'Pipe #2 input at line 41@44-2' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [Utils]Utils/Customer,class [Utils]Utils/Customer>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [Utils]Utils/Customer Invoke(class [Utils]Utils/Customer c) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #2 input at line 41@44-2'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #2 input at line 41@44-2' assembly/'Pipe #2 input at line 41@44-2'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 input at line 50@51-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 input at line 50@51-1' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerable`1<string> Invoke(string _arg1) cil managed
+    {
+      
+      .maxstack  5
+      .locals init (string V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  tail.
+      IL_0005:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Singleton<string>(!!0)
+      IL_000a:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 input at line 50@51-1'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 input at line 50@51-1' assembly/'Pipe #3 input at line 50@51-1'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto autochar serializable sealed nested assembly beforefieldinit specialname 'Pipe #3 input at line 50@52'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .field public class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public int32 pc
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .field public string current
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string> 'enum',
+                                 int32 pc,
+                                 string current) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_0007:  ldarg.0
+      IL_0008:  ldarg.2
+      IL_0009:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_000e:  ldarg.0
+      IL_000f:  ldarg.3
+      IL_0010:  stfld      string assembly/'Pipe #3 input at line 50@52'::current
+      IL_0015:  ldarg.0
+      IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<string>::.ctor()
+      IL_001b:  ret
+    } 
+
+    .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<string>& next) cil managed
+    {
+      
+      .maxstack  7
+      .locals init (string V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0006:  ldc.i4.1
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_001b,
+                            IL_001e,
+                            IL_0021)
+      IL_0019:  br.s       IL_0024
+
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0071
+
+      IL_001e:  nop
+      IL_001f:  br.s       IL_0064
+
+      IL_0021:  nop
+      IL_0022:  br.s       IL_0092
+
+      IL_0024:  nop
+      IL_0025:  ldarg.0
+      IL_0026:  ldsfld     class assembly/'Pipe #3 input at line 50@51-1' assembly/'Pipe #3 input at line 50@51-1'::@_instance
+      IL_002b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+      IL_0030:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!2> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Collect<string,class [runtime]System.Collections.Generic.IEnumerable`1<string>,string>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>,
+                                                                                                                                                                                                                                                  class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0035:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
+      IL_003a:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_003f:  ldarg.0
+      IL_0040:  ldc.i4.1
+      IL_0041:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0046:  br.s       IL_0064
+
+      IL_0048:  ldarg.0
+      IL_0049:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_004e:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<string>::get_Current()
+      IL_0053:  stloc.0
+      IL_0054:  ldarg.0
+      IL_0055:  ldc.i4.2
+      IL_0056:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_005b:  ldarg.0
+      IL_005c:  ldloc.0
+      IL_005d:  stfld      string assembly/'Pipe #3 input at line 50@52'::current
+      IL_0062:  ldc.i4.1
+      IL_0063:  ret
+
+      IL_0064:  ldarg.0
+      IL_0065:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_006a:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_006f:  brtrue.s   IL_0048
+
+      IL_0071:  ldarg.0
+      IL_0072:  ldc.i4.3
+      IL_0073:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0078:  ldarg.0
+      IL_0079:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_007e:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+      IL_0083:  nop
+      IL_0084:  ldarg.0
+      IL_0085:  ldnull
+      IL_0086:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+      IL_008b:  ldarg.0
+      IL_008c:  ldc.i4.3
+      IL_008d:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0092:  ldarg.0
+      IL_0093:  ldnull
+      IL_0094:  stfld      string assembly/'Pipe #3 input at line 50@52'::current
+      IL_0099:  ldc.i4.0
+      IL_009a:  ret
+    } 
+
+    .method public strict virtual instance void Close() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0006:  ldc.i4.3
+      IL_0007:  sub
+      IL_0008:  switch     ( 
+                            IL_0013)
+      IL_0011:  br.s       IL_0016
+
+      IL_0013:  nop
+      IL_0014:  br.s       IL_0076
+
+      IL_0016:  nop
+      .try
+      {
+        IL_0017:  ldarg.0
+        IL_0018:  ldfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+        IL_001d:  switch     ( 
+                              IL_0034,
+                              IL_0037,
+                              IL_003a,
+                              IL_003d)
+        IL_0032:  br.s       IL_0040
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0056
+
+        IL_0037:  nop
+        IL_0038:  br.s       IL_0042
+
+        IL_003a:  nop
+        IL_003b:  br.s       IL_0041
+
+        IL_003d:  nop
+        IL_003e:  br.s       IL_0056
+
+        IL_0040:  nop
+        IL_0041:  nop
+        IL_0042:  ldarg.0
+        IL_0043:  ldc.i4.3
+        IL_0044:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+        IL_0049:  ldarg.0
+        IL_004a:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<string> assembly/'Pipe #3 input at line 50@52'::'enum'
+        IL_004f:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<string>>(!!0)
+        IL_0054:  nop
+        IL_0055:  nop
+        IL_0056:  ldarg.0
+        IL_0057:  ldc.i4.3
+        IL_0058:  stfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+        IL_005d:  ldarg.0
+        IL_005e:  ldnull
+        IL_005f:  stfld      string assembly/'Pipe #3 input at line 50@52'::current
+        IL_0064:  leave.s    IL_0070
+
+      }  
+      catch [runtime]System.Object 
+      {
+        IL_0066:  castclass  [runtime]System.Exception
+        IL_006b:  stloc.1
+        IL_006c:  ldloc.1
+        IL_006d:  stloc.0
+        IL_006e:  leave.s    IL_0070
+
+      }  
+      IL_0070:  nop
+      IL_0071:  br         IL_0000
+
+      IL_0076:  ldloc.0
+      IL_0077:  brfalse.s  IL_007b
+
+      IL_0079:  ldloc.0
+      IL_007a:  throw
+
+      IL_007b:  ret
+    } 
+
+    .method public strict virtual instance bool get_CheckClose() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/'Pipe #3 input at line 50@52'::pc
+      IL_0006:  switch     ( 
+                            IL_001d,
+                            IL_0020,
+                            IL_0023,
+                            IL_0026)
+      IL_001b:  br.s       IL_0029
+
+      IL_001d:  nop
+      IL_001e:  br.s       IL_002e
+
+      IL_0020:  nop
+      IL_0021:  br.s       IL_002c
+
+      IL_0023:  nop
+      IL_0024:  br.s       IL_002a
+
+      IL_0026:  nop
+      IL_0027:  br.s       IL_002e
+
+      IL_0029:  nop
+      IL_002a:  ldc.i4.1
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.1
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+    } 
+
+    .method public strict virtual instance string get_LastGenerated() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string assembly/'Pipe #3 input at line 50@52'::current
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<string> GetFreshEnumerator() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldc.i4.0
+      IL_0002:  ldnull
+      IL_0003:  newobj     instance void assembly/'Pipe #3 input at line 50@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                             int32,
+                                                                                             string)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'Pipe #3 stage #1 at line 54@54'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<int32,string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>
+  {
+    .field static assembly initonly class assembly/'Pipe #3 stage #1 at line 54@54' @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.OptimizedClosures/FSharpFunc`3<int32,string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> 
+            Invoke(int32 i,
+                   string d) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  nop
+      IL_0001:  ldarg.2
+      IL_0002:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0007:  ldarg.1
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  ldarg.2
+      IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<!0> class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>::Some(!0)
+      IL_0010:  ret
+
+      IL_0011:  ldnull
+      IL_0012:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/'Pipe #3 stage #1 at line 54@54'::.ctor()
+      IL_0005:  stsfld     class assembly/'Pipe #3 stage #1 at line 54@54' assembly/'Pipe #3 stage #1 at line 54@54'::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit shortDigits@55
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>
+  {
+    .field static assembly initonly class assembly/shortDigits@55 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  tail.
+      IL_0003:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.Operators::Identity<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>(!!0)
+      IL_0008:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/shortDigits@55::.ctor()
+      IL_0005:  stsfld     class assembly/shortDigits@55 assembly/shortDigits@55::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> numbers@9
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> lowNums@12
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> products@20
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> soldOutProducts@22
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> expensiveInStockProducts@30
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> customers@38
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [Utils]Utils/Customer[] waCustomers@40
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> digits@48
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [runtime]System.Collections.Generic.IEnumerable`1<string> shortDigits@49
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_numbers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@9
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_lowNums() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::lowNums@12
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> get_products() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@20
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> get_soldOutProducts() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::soldOutProducts@22
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> get_expensiveInStockProducts() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::expensiveInStockProducts@30
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> get_customers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@38
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [Utils]Utils/Customer[] get_waCustomers() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [Utils]Utils/Customer[] assembly::waCustomers@40
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> get_digits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@48
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.IEnumerable`1<string> get_shortDigits() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::shortDigits@49
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  13
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_1,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_2,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_3,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Customer> V_4,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_5,
+             class [runtime]System.Collections.Generic.IEnumerable`1<string> V_6,
+             class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder V_7,
+             class [runtime]System.Collections.Generic.IEnumerable`1<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>> V_8)
+    IL_0000:  ldc.i4.5
+    IL_0001:  ldc.i4.4
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.3
+    IL_0004:  ldc.i4.s   9
+    IL_0006:  ldc.i4.8
+    IL_0007:  ldc.i4.6
+    IL_0008:  ldc.i4.7
+    IL_0009:  ldc.i4.2
+    IL_000a:  ldc.i4.0
+    IL_000b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0010:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0015:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001a:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_001f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0024:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0029:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_002e:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0033:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_003d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0042:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::numbers@9
+    IL_0047:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_004c:  stloc.1
+    IL_004d:  ldloc.1
+    IL_004e:  ldloc.1
+    IL_004f:  ldloc.1
+    IL_0050:  ldloc.1
+    IL_0051:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+    IL_0056:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_005b:  ldloc.1
+    IL_005c:  newobj     instance void assembly/'Pipe #1 input at line 13@14'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0061:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<int32,class [runtime]System.Collections.IEnumerable,int32,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_0066:  ldsfld     class assembly/'Pipe #1 input at line 13@15-1' assembly/'Pipe #1 input at line 13@15-1'::@_instance
+    IL_006b:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<int32,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0070:  ldsfld     class assembly/'Pipe #1 input at line 13@16-2' assembly/'Pipe #1 input at line 13@16-2'::@_instance
+    IL_0075:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<int32,class [runtime]System.Collections.IEnumerable,int32>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_007a:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<int32,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_007f:  stloc.0
+    IL_0080:  ldloc.0
+    IL_0081:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> [FSharp.Core]Microsoft.FSharp.Collections.ListModule::OfSeq<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0086:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::lowNums@12
+    IL_008b:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> [Utils]Utils::getProductList()
+    IL_0090:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::products@20
+    IL_0095:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_009a:  stloc.2
+    IL_009b:  ldloc.2
+    IL_009c:  ldloc.2
+    IL_009d:  ldloc.2
+    IL_009e:  ldloc.2
+    IL_009f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_00a4:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00a9:  ldloc.2
+    IL_00aa:  newobj     instance void assembly/soldOutProducts@24::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00af:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00b4:  ldsfld     class assembly/'soldOutProducts@25-1' assembly/'soldOutProducts@25-1'::@_instance
+    IL_00b9:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00be:  ldsfld     class assembly/'soldOutProducts@26-2' assembly/'soldOutProducts@26-2'::@_instance
+    IL_00c3:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_00c8:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_00cd:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::soldOutProducts@22
+    IL_00d2:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_00d7:  stloc.3
+    IL_00d8:  ldloc.3
+    IL_00d9:  ldloc.3
+    IL_00da:  ldloc.3
+    IL_00db:  ldloc.3
+    IL_00dc:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+    IL_00e1:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Product>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_00e6:  ldloc.3
+    IL_00e7:  newobj     instance void assembly/expensiveInStockProducts@32::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_00ec:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_00f1:  ldsfld     class assembly/'expensiveInStockProducts@33-1' assembly/'expensiveInStockProducts@33-1'::@_instance
+    IL_00f6:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                          class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_00fb:  ldsfld     class assembly/'expensiveInStockProducts@34-2' assembly/'expensiveInStockProducts@34-2'::@_instance
+    IL_0100:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Product>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0105:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Product,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_010a:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::expensiveInStockProducts@30
+    IL_010f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> [Utils]Utils::getCustomerList()
+    IL_0114:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::customers@38
+    IL_0119:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_011e:  stloc.s    V_5
+    IL_0120:  ldloc.s    V_5
+    IL_0122:  ldloc.s    V_5
+    IL_0124:  ldloc.s    V_5
+    IL_0126:  ldloc.s    V_5
+    IL_0128:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+    IL_012d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,class [runtime]System.Collections.IEnumerable> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Source<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0132:  ldloc.s    V_5
+    IL_0134:  newobj     instance void assembly/'Pipe #2 input at line 41@42'::.ctor(class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder)
+    IL_0139:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::For<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Customer,object>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                            class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!3>>)
+    IL_013e:  ldsfld     class assembly/'Pipe #2 input at line 41@43-1' assembly/'Pipe #2 input at line 41@43-1'::@_instance
+    IL_0143:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Where<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,bool>)
+    IL_0148:  ldsfld     class assembly/'Pipe #2 input at line 41@44-2' assembly/'Pipe #2 input at line 41@44-2'::@_instance
+    IL_014d:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!2,!!1> [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder::Select<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable,class [Utils]Utils/Customer>(class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<!!0,!!1>,
+                                                                                                                                                                                                                                                                        class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!2>)
+    IL_0152:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerable`1<!0> class [FSharp.Core]Microsoft.FSharp.Linq.QuerySource`2<class [Utils]Utils/Customer,class [runtime]System.Collections.IEnumerable>::get_Source()
+    IL_0157:  stloc.s    V_4
+    IL_0159:  ldloc.s    V_4
+    IL_015b:  call       !!0[] [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::ToArray<class [Utils]Utils/Customer>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_0160:  stsfld     class [Utils]Utils/Customer[] assembly::waCustomers@40
+    IL_0165:  ldstr      "zero"
+    IL_016a:  ldstr      "one"
+    IL_016f:  ldstr      "two"
+    IL_0174:  ldstr      "three"
+    IL_0179:  ldstr      "four"
+    IL_017e:  ldstr      "five"
+    IL_0183:  ldstr      "six"
+    IL_0188:  ldstr      "seven"
+    IL_018d:  ldstr      "eight"
+    IL_0192:  ldstr      "nine"
+    IL_0197:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::get_Empty()
+    IL_019c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01a1:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01a6:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01ab:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01b0:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01b5:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01ba:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01bf:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01c4:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01c9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>::Cons(!0,
+                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_01ce:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::digits@48
+    IL_01d3:  call       class [FSharp.Core]Microsoft.FSharp.Linq.QueryBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_query()
+    IL_01d8:  stloc.s    V_7
+    IL_01da:  ldnull
+    IL_01db:  ldc.i4.0
+    IL_01dc:  ldnull
+    IL_01dd:  newobj     instance void assembly/'Pipe #3 input at line 50@52'::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<string>,
+                                                                                           int32,
+                                                                                           string)
+    IL_01e2:  stloc.s    V_6
+    IL_01e4:  ldsfld     class assembly/'Pipe #3 stage #1 at line 54@54' assembly/'Pipe #3 stage #1 at line 54@54'::@_instance
+    IL_01e9:  ldloc.s    V_6
+    IL_01eb:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::MapIndexed<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,!!1>>,
+                                                                                                                                                                                                                                     class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01f0:  stloc.s    V_8
+    IL_01f2:  ldsfld     class assembly/shortDigits@55 assembly/shortDigits@55::@_instance
+    IL_01f7:  ldloc.s    V_8
+    IL_01f9:  call       class [runtime]System.Collections.Generic.IEnumerable`1<!!1> [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Choose<class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string>,string>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<!!1>>,
+                                                                                                                                                                                                                                 class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+    IL_01fe:  stsfld     class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::shortDigits@49
+    IL_0203:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          numbers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_numbers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          lowNums()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_lowNums()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product>
+          products()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Product> assembly::get_products()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>
+          soldOutProducts()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::get_soldOutProducts()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product>
+          expensiveInStockProducts()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<class [Utils]Utils/Product> assembly::get_expensiveInStockProducts()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer>
+          customers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<class [Utils]Utils/Customer> assembly::get_customers()
+  } 
+  .property class [Utils]Utils/Customer[]
+          waCustomers()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [Utils]Utils/Customer[] assembly::get_waCustomers()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string>
+          digits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<string> assembly::get_digits()
+  } 
+  .property class [runtime]System.Collections.Generic.IEnumerable`1<string>
+          shortDigits()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.IEnumerable`1<string> assembly::get_shortDigits()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/QueryExpressionStepping.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/QueryExpressionStepping.fs
index 8cd5778d97f..ff590c10dae 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/QueryExpressionStepping.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/QueryExpressionStepping/QueryExpressionStepping.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open Xunit
 open System.IO
@@ -24,61 +24,138 @@ module QueryExpressionStepping =
         |> verifyILBaseline
 
     // SOURCE=Linq101Aggregates01.fs         SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101Aggregates01.exe"        # Linq101Aggregates01.fs - CodeGen
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Linq101Aggregates01.fs"|])>]
-    let ``Linq101Aggregates01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Linq101Aggregates01.fs"|])>]
+    let ``Linq101Aggregates01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Linq101Aggregates01.fs"|])>]
+    let ``Linq101Aggregates01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=Linq101ElementOperators01.fs   SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101ElementOperators01.exe"  # Linq101ElementOperators01.fs - CodeGen
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Linq101ElementOperators01.fs"|])>]
+    let ``Linq101ElementOperators01_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
     // SOURCE=Linq101ElementOperators01.fs   SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101ElementOperators01.exe"  # Linq101ElementOperators01.fs - CodeGen
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Linq101ElementOperators01.fs"|])>]
-    let ``Linq101ElementOperators01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Linq101ElementOperators01.fs"|])>]
+    let ``Linq101ElementOperators01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=Linq101Grouping01.fs           SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101Grouping01.exe"          # Linq101Grouping01.fs - CodeGen
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Linq101Grouping01.fs"|])>]
+    let ``Linq101Grouping01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=Linq101Grouping01.fs           SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101Grouping01.exe"          # Linq101Grouping01.fs - CodeGen
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Linq101Grouping01.fs"|])>]
-    let ``Linq101Grouping01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Linq101Grouping01.fs"|])>]
+    let ``Linq101Grouping01_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     // SOURCE=Linq101Joins01.fs              SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101Joins01.exe"             # Linq101Joins01.fs - CodeGen
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Linq101Joins01.fs"|])>]
-    let ``Linq101Joins01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Linq101Joins01.fs"|])>]
+    let ``Linq101Joins01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    // SOURCE=Linq101Joins01.fs              SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101Joins01.exe"             # Linq101Joins01.fs - CodeGen
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Linq101Joins01.fs"|])>]
+    let ``Linq101Joins01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     // SOURCE=Linq101Ordering01.fs           SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101Ordering01.exe"          # Linq101Ordering01.fs - CodeGen
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Linq101Ordering01.fs"|])>]
-    let ``Linq101Ordering01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Linq101Ordering01.fs"|])>]
+    let ``Linq101Ordering01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    // SOURCE=Linq101Ordering01.fs           SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101Ordering01.exe"          # Linq101Ordering01.fs - CodeGen
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Linq101Ordering01.fs"|])>]
+    let ``Linq101Ordering01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     // SOURCE=Linq101Partitioning01.fs       SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101Partitioning01.exe"      # Linq101Partitioning01.fs - CodeGen
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Linq101Partitioning01.fs"|])>]
-    let ``Linq101Partitioning01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Linq101Partitioning01.fs"|])>]
+    let ``Linq101Partitioning01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    // SOURCE=Linq101Partitioning01.fs       SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101Partitioning01.exe"      # Linq101Partitioning01.fs - CodeGen
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Linq101Partitioning01.fs"|])>]
+    let ``Linq101Partitioning01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     // SOURCE=Linq101Quantifiers01.fs        SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101Quantifiers01.exe"       # Linq101Quantifiers01.fs - CodeGen
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Linq101Quantifiers01.fs"|])>]
-    let ``Linq101Quantifiers01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Linq101Quantifiers01.fs"|])>]
+    let ``Linq101Quantifiers01_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Linq101Quantifiers01.fs"|])>]
+    let ``Linq101Quantifiers01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+        // SOURCE=Linq101Select01.fs             SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101Select01.exe"            # Linq101Select01.fs - CodeGen
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Linq101Select01.fs"|])>]
+    let ``Linq101Select01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
         // SOURCE=Linq101Select01.fs             SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101Select01.exe"            # Linq101Select01.fs - CodeGen
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Linq101Select01.fs"|])>]
-    let ``Linq101Select01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Linq101Select01.fs"|])>]
+    let ``Linq101Select01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=Linq101SetOperators01.fs       SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101SetOperators01.exe"      # Linq101SetOperators01.fs - CodeGen
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Linq101SetOperators01.fs"|])>]
+    let ``Linq101SetOperators01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=Linq101SetOperators01.fs       SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101SetOperators01.exe"      # Linq101SetOperators01.fs - CodeGen
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Linq101SetOperators01.fs"|])>]
-    let ``Linq101SetOperators01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Linq101SetOperators01.fs"|])>]
+    let ``Linq101SetOperators01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=Linq101Where01.fs              SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101Where01.exe"             # Linq101Where01.fs - CodeGen
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Linq101Where01.fs"|])>]
+    let ``Linq101Where01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=Linq101Where01.fs              SCFLAGS="-r:Utils.dll -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Linq101Where01.exe"             # Linq101Where01.fs - CodeGen
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Linq101Where01.fs"|])>]
-    let ``Linq101Where01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Linq101Where01.fs"|])>]
+    let ``Linq101Where01_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeInitialization.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeInitialization.fs
new file mode 100644
index 00000000000..19165b3fe8c
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeInitialization.fs
@@ -0,0 +1,861 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace EmittedIL.RealInternalSignature
+
+open Xunit
+open FSharp.Test
+open FSharp.Test.Compiler
+
+module ClassTypeInitialization =
+
+    let withRealInternalSignature realSig compilation =
+        compilation
+        |> withOptions [if realSig then "--realsig+" else "--realsig-" ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Simple types in namespace`` (realSig) =
+
+        FSharp """
+namespace MyLibrary
+type MyFirstType =
+    static let x1 = 1100 + System.Random().Next(0)
+    static let _ = printfn "Hello, World from MyLibrary.MyFirstType"
+
+type MySecondType =
+    static let x2 = 2100 + System.Random().Next(0)
+    static let _ = printfn "Hello, World from MyLibrary.MySecondType"
+
+module MyModule =
+    [<EntryPoint>]
+    let main args =
+        printfn "Hello from main method"
+        0
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from MyLibrary.MyFirstType"
+            "Hello, World from MyLibrary.MySecondType"
+            "Hello from main method"
+        ]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Simple types in implicit main`` (realSig) =
+
+        FSharp """
+type MyFirstType =
+    static let x1 = 1100 + System.Random().Next(0)
+    static let _ = printfn "Hello, World from MyProgram.MyFirstType"
+
+type MySecondType =
+    static let x2 = 2100 + System.Random().Next(0)
+    static let _ = printfn "Hello, World from MyProgram.MySecondType"
+
+printfn "Hello from implicit main method"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from MyProgram.MyFirstType"
+            "Hello, World from MyProgram.MySecondType"
+            "Hello from implicit main method"
+        ]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Simple TypeOne and TypeTwo in namespace`` (realSig) =
+
+        FSharp """
+namespace MyLibrary
+type MyFirstType =
+    static let x1 = 1100 + System.Random().Next(0)
+    static let _ = printfn "Hello, World from MyLibrary.MyFirstType"
+
+and MySecondType =
+    static let x2 = 2100 + System.Random().Next(0)
+    static let _ = printfn "Hello, World from MyLibrary.MySecondType"
+
+module MyModule =
+    [<EntryPoint>]
+    let main args =
+        printfn "Hello from main method"
+        0
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from MyLibrary.MyFirstType"
+            "Hello, World from MyLibrary.MySecondType"
+            "Hello from main method"
+        ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Public type - public ctor`` (realSig) =
+
+        FSharp """
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type FSharpSourceFromFile public (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+type FSharpSource with
+
+    static member CreateFromFile (filePath: string) =
+        ()  //FSharpSourceFromFile(filePath) :> FSharpSource
+
+module doit =
+    FSharpSource.CreateFromFile("Hello") |> ignore
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Public type - internal ctor`` (realSig) =
+
+        FSharp """
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type FSharpSourceFromFile internal (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+type FSharpSource with
+
+    static member CreateFromFile(filePath: string) =
+        FSharpSourceFromFile(filePath) :> FSharpSource
+
+module doit =
+    FSharpSource.CreateFromFile("Hello") |> ignore
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Public type - private ctor`` (realSig) =
+
+        FSharp """
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type FSharpSourceFromFile private (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+type FSharpSource with
+
+    static member CreateFromFile (filePath: string) =
+        ()  //FSharpSourceFromFile(filePath) :> FSharpSource
+
+module doit =
+    FSharpSource.CreateFromFile("Hello") |> ignore
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Public type - unspecified ctor`` (realSig) =
+
+        FSharp """
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type FSharpSourceFromFile (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+type FSharpSource with
+
+    static member CreateFromFile (filePath: string) =
+        ()  //FSharpSourceFromFile(filePath) :> FSharpSource
+
+module doit =
+    FSharpSource.CreateFromFile("Hello") |> ignore
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Private type - public ctor`` (realSig) =
+
+        FSharp """
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type private FSharpSourceFromFile public (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+type FSharpSource with
+
+    static member CreateFromFile (filePath: string) =
+        ()  //FSharpSourceFromFile(filePath) :> FSharpSource
+
+module doit =
+    FSharpSource.CreateFromFile("Hello") |> ignore
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Private type - internal ctor`` (realSig) =
+
+        FSharp """
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type private FSharpSourceFromFile internal (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+type FSharpSource with
+
+    static member CreateFromFile(filePath: string) =
+        FSharpSourceFromFile(filePath) :> FSharpSource
+
+module doit =
+    FSharpSource.CreateFromFile("Hello") |> ignore
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Private type - private ctor`` (realSig) =
+
+        FSharp """
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type public FSharpSourcePublic () =
+    abstract PublicFilePath: string
+
+[<AbstractClass>]
+type internal FSharpSource () =
+    inherit FSharpSourcePublic()
+    abstract InternalFilePath: string
+
+type private FSharpSourceFromFile private (filePath: string) =
+    inherit FSharpSource()
+
+    override _.PublicFilePath = filePath
+    override _.InternalFilePath = filePath
+    member   _.PrivateFilePath = filePath
+
+type FSharpSource with
+
+    static member public PublicCreateFromFile (filePath: string) = ()
+    static member internal InternalCreateFromFile (filePath: string) = ()
+    static member private PrivateCreateFromFile (filePath: string) = ()
+
+module doit =
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Private type - unspecified ctor`` (realSig) =
+
+        FSharp """
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type private FSharpSourceFromFile (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+type FSharpSource with
+
+    static member CreateFromFile (filePath: string) =
+        FSharpSourceFromFile(filePath) :> FSharpSource
+
+module doit =
+    FSharpSource.CreateFromFile("Hello") |> ignore
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Static Initialization - don't inline when method includes a private field`` (realSig) =
+
+        FSharp """
+module FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type public FSharpSourceFromFile private (filePath: string) =
+    inherit FSharpSource()
+
+    static let mutable someValue = "not set yet"
+
+    override _.FilePath = filePath
+
+    static member private SetSomeValue (value: string): string =
+        someValue <- value
+        someValue
+
+    static member public SetIt (value: string) : string =
+        FSharpSourceFromFile.SetSomeValue (value)
+
+let message = FSharpSourceFromFile.SetIt ("Here is something")
+
+printfn $"{message}"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Here is something"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Computation expression - access private binding`` (realSig) =
+
+        FSharp """
+module MyMaybeStuff =
+    type MaybeBuilder() =
+        member this.Bind(x, f) =
+            match x with
+            | Some v -> f v
+            | None -> None
+        member this.Return(x) = Some x
+
+    let maybe = new MaybeBuilder()
+
+open MyMaybeStuff
+type MyClass =
+    static member private privateThing(someValue) = someValue
+
+    static member result () =
+        maybe {
+            let mutable someValue = 0
+            let! u = someValue <- 1; Some (MyClass.privateThing(someValue))
+            let! v = someValue <- 2; Some (MyClass.privateThing(someValue))
+            return u + v
+        }
+
+printfn "%A" (MyClass.result())
+"""
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> withNoOptimize
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Some 3"
+        ]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``nested generic closure`` (realSig) =
+
+        FSharp """
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace MyCollections
+
+#nowarn "52" // The value has been copied to ensure the original is not mutated by this operation
+
+open System.Diagnostics
+open System.Collections
+open System.Collections.Generic
+open Microsoft.FSharp.Core
+
+module internal IEnumerator =
+
+    let noReset() = raise (new System.NotSupportedException("SR.GetString(SR.resetNotSupported)"))
+    let notStarted() = raise (new System.InvalidOperationException("SR.GetString(SR.enumerationNotStarted)"))
+    let alreadyFinished() = raise (new System.InvalidOperationException("SR.GetString(SR.enumerationAlreadyFinished)"))
+    let check started = if not started then notStarted()
+    let dispose (r : System.IDisposable) = r.Dispose()
+
+    let cast (e : IEnumerator) : IEnumerator<'T> =
+        { new IEnumerator<'T> with
+              member _.Current = unbox<'T> e.Current
+
+          interface IEnumerator with
+              member _.Current = unbox<'T> e.Current :> obj
+
+              [<DebuggerStepThrough>]
+              member _.MoveNext() = e.MoveNext()
+
+              member _.Reset() = noReset()
+
+          interface System.IDisposable with
+              member _.Dispose() =
+                  match e with
+                  | :? System.IDisposable as e -> e.Dispose()
+                  | _ -> ()   }
+
+    /// A concrete implementation of an enumerator that returns no values
+    [<Sealed>]
+    type EmptyEnumerator<'T>() =
+        let mutable started = false
+        interface IEnumerator<'T> with
+            member _.Current =
+                check started
+                (alreadyFinished() : 'T)
+
+        interface System.Collections.IEnumerator with
+            member _.Current =
+                check started
+                (alreadyFinished() : obj)
+
+            [<DebuggerStepThrough>]
+            member _.MoveNext() =
+                if not started then started <- true
+                false
+
+            member _.Reset() = noReset()
+
+        interface System.IDisposable with
+             member _.Dispose() = ()
+            
+    let Empty<'T> () = (new EmptyEnumerator<'T>() :> IEnumerator<'T>)
+
+    [<NoEquality; NoComparison>]
+    type EmptyEnumerable<'T> =
+
+        | EmptyEnumerable
+
+        interface IEnumerable<'T> with
+            member _.GetEnumerator() = Empty<'T>()
+
+        interface IEnumerable with
+            member _.GetEnumerator() = (Empty<'T>() :> IEnumerator)
+
+    type GeneratedEnumerable<'T, 'State>(openf: unit -> 'State, compute: 'State -> 'T option, closef: 'State -> unit) =
+        let mutable started = false
+        let mutable curr = None
+        let state = ref (Some (openf ()))
+        let getCurr() : 'T =
+            check started
+            match curr with
+            | None -> alreadyFinished()
+            | Some x -> x
+
+        let readAndClear () =
+            lock state (fun () ->
+                match state.Value with
+                | None -> None
+                | Some _ as res ->
+                    state.Value <- None
+                    res)
+
+        let start() =
+            if not started then
+                started <- true
+
+        let dispose() =
+            readAndClear() |> Option.iter closef
+
+        let finish() =
+            try dispose()
+            finally curr <- None
+
+        interface IEnumerator<'T> with
+            member _.Current = getCurr()
+
+        interface IEnumerator with
+            member _.Current = box (getCurr())
+
+            [<DebuggerStepThrough>]
+            member _.MoveNext() =
+                start()
+                match state.Value with
+                | None -> false // we started, then reached the end, then got another MoveNext
+                | Some s ->
+                    match (try compute s with e -> finish(); reraise()) with
+                    | None -> finish(); false
+                    | Some _ as x ->
+                        curr <- x
+                        true
+
+            member _.Reset() = noReset()
+
+        interface System.IDisposable with
+             member _.Dispose() = dispose()
+
+    [<Sealed>]
+    type Singleton<'T>(v:'T) =
+        let mutable started = false
+
+        interface IEnumerator<'T> with
+             member _.Current = v
+
+        interface IEnumerator with
+            member _.Current = box v
+
+            [<DebuggerStepThrough>]
+            member _.MoveNext() = if started then false else (started <- true; true)
+
+            member _.Reset() = noReset()
+
+        interface System.IDisposable with
+            member _.Dispose() = ()
+
+    let Singleton x = (new Singleton<'T>(x) :> IEnumerator<'T>)
+
+    let EnumerateThenFinally f (e : IEnumerator<'T>) =
+        { new IEnumerator<'T> with
+             member _.Current = e.Current
+
+          interface IEnumerator with
+              member _.Current = (e :> IEnumerator).Current
+
+              [<DebuggerStepThrough>]
+              member _.MoveNext() = e.MoveNext()
+
+              member _.Reset() = noReset()
+
+          interface System.IDisposable with
+              member _.Dispose() =
+                  try
+                      e.Dispose()
+                  finally
+                      f()
+        }
+
+    let inline checkNonNull argName arg =
+        if isNull arg then
+            nullArg argName
+
+    let mkSeq f =
+        { new IEnumerable<'U> with
+            member _.GetEnumerator() = f()
+
+          interface IEnumerable with
+            member _.GetEnumerator() = (f() :> IEnumerator) }
+
+namespace Microsoft.FSharp.Core.CompilerServices
+
+    open System.Diagnostics
+    open Microsoft.FSharp.Core
+    open MyCollections
+    open MyCollections.IEnumerator
+    open System.Collections
+    open System.Collections.Generic
+
+    module RuntimeHelpers =
+
+        [<Struct; NoComparison; NoEquality>]
+        type internal StructBox<'T when 'T:equality>(value:'T) =
+            member x.Value = value
+
+            static member Comparer =
+                let gcomparer = HashIdentity.Structural<'T>
+                { new IEqualityComparer<StructBox<'T>> with
+                       member _.GetHashCode(v) = gcomparer.GetHashCode(v.Value)
+                       member _.Equals(v1,v2) = gcomparer.Equals(v1.Value,v2.Value) }
+
+        let Generate openf compute closef =
+            mkSeq (fun () -> new IEnumerator.GeneratedEnumerable<_,_>(openf, compute, closef) :> IEnumerator<'T>)
+
+        let EnumerateFromFunctions create moveNext current =
+            Generate
+                create
+                (fun x -> if moveNext x then Some(current x) else None)
+                (fun x -> match box(x) with :? System.IDisposable as id -> id.Dispose() | _ -> ())
+
+        // A family of enumerators that can have additional 'finally' actions added to the enumerator through
+        // the use of mutation. This is used to 'push' the disposal action for a 'use' into the next enumerator.
+        // For example,
+        //    seq { use x = ...
+        //          while ... }
+        // results in the 'while' loop giving an adjustable enumerator. This is then adjusted by adding the disposal action
+        // from the 'use' into the enumerator. This means that we avoid constructing a two-deep enumerator chain in this
+        // common case.
+        type IFinallyEnumerator =
+            abstract AppendFinallyAction : (unit -> unit) -> unit
+
+        /// A concrete implementation of IEnumerable that adds the given compensation to the "Dispose" chain of any
+        /// enumerators returned by the enumerable.
+        [<Sealed>]
+        type FinallyEnumerable<'T>(compensation: unit -> unit, restf: unit -> seq<'T>) =
+            interface IEnumerable<'T> with
+                member _.GetEnumerator() =
+                    try
+                        let ie = restf().GetEnumerator()
+                        match ie with
+                        | :? IFinallyEnumerator as a ->
+                            a.AppendFinallyAction(compensation)
+                            ie
+                        | _ ->
+                            IEnumerator.EnumerateThenFinally compensation ie
+                    with e ->
+                        compensation()
+                        reraise()
+            interface IEnumerable with
+                member x.GetEnumerator() = ((x :> IEnumerable<'T>).GetEnumerator() :> IEnumerator)
+
+        /// An optimized object for concatenating a sequence of enumerables
+        [<Sealed>]
+        type ConcatEnumerator<'T,'U when 'U :> seq<'T>>(sources: seq<'U>) =
+            let mutable outerEnum = sources.GetEnumerator()
+            let mutable currInnerEnum = IEnumerator.Empty()
+
+            let mutable started = false
+            let mutable finished = false
+            let mutable compensations = []
+
+            [<DefaultValue(false)>] // false = unchecked
+            val mutable private currElement : 'T
+
+            member _.Finish() =
+                finished <- true
+                try
+                    match currInnerEnum with
+                    | null -> ()
+                    | _ ->
+                        try
+                            currInnerEnum.Dispose()
+                        finally
+                            currInnerEnum <- null
+                finally
+                    try
+                        match outerEnum with
+                        | null -> ()
+                        | _ ->
+                            try
+                                outerEnum.Dispose()
+                            finally
+                                outerEnum <- null
+                    finally
+                        let rec iter comps =
+                            match comps with
+                            |   [] -> ()
+                            |   h :: t ->
+                                    try h() finally iter t
+                        try
+                            compensations |> List.rev |> iter
+                        finally
+                            compensations <- []
+
+            member x.GetCurrent() =
+                IEnumerator.check started
+                if finished then IEnumerator.alreadyFinished() else x.currElement
+
+            interface IFinallyEnumerator with
+                member _.AppendFinallyAction(f) =
+                    compensations <- f :: compensations
+
+            interface IEnumerator<'T> with
+                member x.Current = x.GetCurrent()
+
+            interface IEnumerator with
+                member x.Current = box (x.GetCurrent())
+
+                [<DebuggerStepThrough>]
+                member x.MoveNext() =
+                   if not started then started <- true
+                   if finished then false
+                   else
+                      let rec takeInner () =
+                        // check the inner list
+                        if currInnerEnum.MoveNext() then
+                            x.currElement <- currInnerEnum.Current
+                            true
+                        else
+                            // check the outer list
+                            let rec takeOuter() =
+                                if outerEnum.MoveNext() then
+                                    let ie = outerEnum.Current
+                                    // Optimization to detect the statically-allocated empty IEnumerables
+                                    match box ie with
+                                    | :? EmptyEnumerable<'T> ->
+                                         // This one is empty, just skip, don't call GetEnumerator, try again
+                                         takeOuter()
+                                    | _ ->
+                                         // OK, this one may not be empty.
+                                         // Don't forget to dispose of the enumerator for the inner list now we're done with it
+                                         currInnerEnum.Dispose()
+                                         currInnerEnum <- ie.GetEnumerator()
+                                         takeInner ()
+                                else
+                                    // We're done
+                                    x.Finish()
+                                    false
+                            takeOuter()
+                      takeInner ()
+
+                member _.Reset() = IEnumerator.noReset()
+
+            interface System.IDisposable with
+
+                [<DebuggerStepThrough>]
+                member x.Dispose() =
+                    if not finished then
+                        x.Finish()
+
+    module doIt =
+        open System
+        open Microsoft.FSharp.Core.CompilerServices
+        open Microsoft.FSharp.Collections
+
+        let x = seq { ArraySegment([|1uy; 2uy; 3uy|]); ArraySegment([|1uy; 2uy; 3uy|]); ArraySegment([|1uy; 2uy; 3uy|]); }
+        let enumerator = new RuntimeHelpers.ConcatEnumerator<_,_>(x) :> IEnumerator
+        let rec loop () =
+            if enumerator.MoveNext() then
+                printfn $"{enumerator.Current}"
+                loop ()
+        loop ()
+"""
+        |> asExe
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> withOptimize
+        |> compileAndRun
+        |> shouldSucceed
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeVisibility.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeVisibility.fs
new file mode 100644
index 00000000000..acd800eb0a6
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeVisibility.fs
@@ -0,0 +1,3291 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace EmittedIL.RealInternalSignature
+
+open Xunit
+open FSharp.Test
+open FSharp.Test.Compiler
+
+module ClassTypeVisibilityModuleRoot =
+
+    let withRealInternalSignature realSig compilation =
+        compilation
+        |> withOptions [if realSig then "--realsig+" else "--realsig-" ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - various constructors`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TypeOne public () = class end
+type public TypeTwo internal () = class end
+type public TypeThree private () = class end
+type public TypeFour () = class end
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            """  .class auto ansi serializable nested public TypeOne
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor() cil managed"""
+
+            """  .class auto ansi serializable nested public TypeTwo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed"""
+
+            """  .class auto ansi serializable nested public TypeThree
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method assembly specialname rtspecialname 
+            instance void  .ctor() cil managed"""
+
+            """  .class auto ansi serializable nested public TypeFour
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor() cil managed"""
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - various constructors`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type private TypeOne public () = class end
+type private TypeTwo internal () = class end
+type private TypeThree private () = class end
+type private TypeFour () = class end
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                //type private TypeOne public () = class end
+                """.class auto ansi serializable nested private TypeOne
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor() cil managed"""
+
+                //type private TypeTwo internal () = class end
+                """.class auto ansi serializable nested private TypeTwo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor() cil managed"""
+
+                //type private TypeThree private () = class end
+                """.class auto ansi serializable nested private TypeThree
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor() cil managed"""
+
+                //type private TypeFour () = class end
+                """.class auto ansi serializable nested private TypeFour
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor() cil managed"""
+
+        else
+
+                //type private TypeOne public () = class end
+                """.class auto ansi serializable nested assembly TypeOne
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor() cil managed"""
+
+                //type private TypeTwo internal () = class end
+                """.class auto ansi serializable nested assembly TypeTwo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor() cil managed"""
+
+                //type private TypeThree private () = class end
+                """.class auto ansi serializable nested assembly TypeThree
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor() cil managed"""
+
+                //type private TypeFour () = class end
+                """.class auto ansi serializable nested assembly TypeFour
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname 
+            instance void  .ctor() cil managed"""
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - various methods`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    member public _.PublicMethod() = ()
+    member internal _.InternalMethod() = ()
+    member private _.PrivateMethod() = ()
+    member _.DefaultMethod() = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+    .method public hidebysig instance void 
+            PublicMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig instance void 
+            InternalMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method private hidebysig instance void 
+            PrivateMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig instance void 
+            DefaultMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+"""
+            else
+                """
+    .method public hidebysig instance void 
+            PublicMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig instance void 
+            InternalMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig instance void 
+            PrivateMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig instance void 
+            DefaultMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+"""
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - various methods`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    member public _.PublicMethod() = ()
+    member internal _.InternalMethod() = ()
+    member private _.PrivateMethod() = ()
+    member _.DefaultMethod() = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+    .method public hidebysig instance void 
+            PublicMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig instance void 
+            InternalMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method private hidebysig instance void 
+            PrivateMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig instance void 
+            DefaultMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+"""
+            else
+                """
+    .method public hidebysig instance void 
+            PublicMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig instance void 
+            InternalMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig instance void 
+            PrivateMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig instance void 
+            DefaultMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+"""
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - various properties`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    member val public PublicProperty = 0 with get, set
+    member val internal InternalProperty = 0 with get, set
+    member val private PrivateProperty = 0 with get, set
+    member val DefaultProperty = 0 with get, set
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+    .method public hidebysig specialname 
+            instance int32  get_PublicProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::PublicProperty@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_PublicProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::PublicProperty@
+      IL_0007:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_InternalProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::InternalProperty@
+      IL_0006:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_InternalProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::InternalProperty@
+      IL_0007:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance int32  get_PrivateProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::PrivateProperty@
+      IL_0006:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance void  set_PrivateProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::PrivateProperty@
+      IL_0007:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_DefaultProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::DefaultProperty@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_DefaultProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::DefaultProperty@
+      IL_0007:  ret
+    } 
+"""
+            else
+                """
+    .method public hidebysig specialname 
+            instance int32  get_PublicProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::PublicProperty@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_PublicProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::PublicProperty@
+      IL_0007:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_InternalProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::InternalProperty@
+      IL_0006:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_InternalProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::InternalProperty@
+      IL_0007:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_PrivateProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::PrivateProperty@
+      IL_0006:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_PrivateProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::PrivateProperty@
+      IL_0007:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_DefaultProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::DefaultProperty@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_DefaultProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::DefaultProperty@
+      IL_0007:  ret
+    } 
+"""
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - various properties`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    member val public PublicProperty = 0 with get, set
+    member val internal InternalProperty = 0 with get, set
+    member val private PrivateProperty = 0 with get, set
+    member val DefaultProperty = 0 with get, set
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+    .method public hidebysig specialname 
+            instance int32  get_PublicProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::PublicProperty@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_PublicProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::PublicProperty@
+      IL_0007:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_InternalProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::InternalProperty@
+      IL_0006:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_InternalProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::InternalProperty@
+      IL_0007:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance int32  get_PrivateProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::PrivateProperty@
+      IL_0006:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance void  set_PrivateProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::PrivateProperty@
+      IL_0007:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_DefaultProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::DefaultProperty@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_DefaultProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::DefaultProperty@
+      IL_0007:  ret
+    } 
+"""
+            else
+                """
+    .method public hidebysig specialname 
+            instance int32  get_PublicProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::PublicProperty@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_PublicProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::PublicProperty@
+      IL_0007:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_InternalProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::InternalProperty@
+      IL_0006:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_InternalProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::InternalProperty@
+      IL_0007:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_PrivateProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::PrivateProperty@
+      IL_0006:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_PrivateProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::PrivateProperty@
+      IL_0007:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_DefaultProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::DefaultProperty@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_DefaultProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::DefaultProperty@
+      IL_0007:  ret
+    } 
+"""
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - various mixed properties`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    member _.MixedPropertyOne with public get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyTwo with public get() = 0 and private set (_:int) = ()
+    member _.MixedPropertyThree with private get() = 0 and public set (_:int) = ()
+    member _.MixedPropertyFour with private get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyFive with internal get() = 0 and public set (_:int) = ()
+    member _.MixedPropertySix with internal get() = 0 and private set (_:int) = ()
+    member _.MixedPropertySeven with get() = 0 and public set (_:int) = ()
+    member _.MixedPropertyEight with get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyNine with get() = 0 and private set (_:int) = ()
+    member _.MixedPropertyTen with public get() = 0 and set (_:int) = ()
+    member _.MixedPropertyEleven with internal get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTwelve with private get() = 0 and set (_:int) = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyOne() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyOne(int32 _arg1) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyTwo() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance void  set_MixedPropertyTwo(int32 _arg2) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance int32  get_MixedPropertyThree() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyThree(int32 _arg3) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance int32  get_MixedPropertyFour() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyFour(int32 _arg4) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyFive() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyFive(int32 _arg5) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertySix() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance void  set_MixedPropertySix(int32 _arg6) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertySeven() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertySeven(int32 _arg7) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyEight() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyEight(int32 _arg8) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyNine() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance void  set_MixedPropertyNine(int32 _arg9) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyTen() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyTen(int32 _arg10) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyEleven() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyEleven(int32 _arg11) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance int32  get_MixedPropertyTwelve() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+"""
+            else
+                """
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyOne() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyOne(int32 _arg1) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyTwo() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyTwo(int32 _arg2) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyThree() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyThree(int32 _arg3) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyFour() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyFour(int32 _arg4) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyFive() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyFive(int32 _arg5) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertySix() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertySix(int32 _arg6) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertySeven() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertySeven(int32 _arg7) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyEight() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyEight(int32 _arg8) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyNine() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyNine(int32 _arg9) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyTen() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyTen(int32 _arg10) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyEleven() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyEleven(int32 _arg11) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyTwelve() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+"""
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - various mixed properties`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type private TestType () =
+    member _.MixedPropertyOne with public get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyTwo with public get() = 0 and private set (_:int) = ()
+    member _.MixedPropertyThree with private get() = 0 and public set (_:int) = ()
+    member _.MixedPropertyFour with private get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyFive with internal get() = 0 and public set (_:int) = ()
+    member _.MixedPropertySix with internal get() = 0 and private set (_:int) = ()
+    member _.MixedPropertySeven with get() = 0 and public set (_:int) = ()
+    member _.MixedPropertyEight with get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyNine with get() = 0 and private set (_:int) = ()
+    member _.MixedPropertyTen with public get() = 0 and set (_:int) = ()
+    member _.MixedPropertyEleven with internal get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTwelve with private get() = 0 and set (_:int) = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyOne() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyOne(int32 _arg1) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyTwo() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance void  set_MixedPropertyTwo(int32 _arg2) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance int32  get_MixedPropertyThree() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyThree(int32 _arg3) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance int32  get_MixedPropertyFour() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyFour(int32 _arg4) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyFive() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyFive(int32 _arg5) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertySix() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance void  set_MixedPropertySix(int32 _arg6) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertySeven() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertySeven(int32 _arg7) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyEight() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyEight(int32 _arg8) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyNine() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance void  set_MixedPropertyNine(int32 _arg9) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyTen() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyTen(int32 _arg10) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyEleven() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyEleven(int32 _arg11) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance int32  get_MixedPropertyTwelve() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+"""
+            else
+                """
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyOne() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyOne(int32 _arg1) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyTwo() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyTwo(int32 _arg2) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyThree() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyThree(int32 _arg3) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyFour() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyFour(int32 _arg4) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyFive() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyFive(int32 _arg5) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertySix() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertySix(int32 _arg6) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertySeven() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertySeven(int32 _arg7) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyEight() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyEight(int32 _arg8) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyNine() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyNine(int32 _arg9) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyTen() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyTen(int32 _arg10) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyEleven() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyEleven(int32 _arg11) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyTwelve() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+"""
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - various static methods`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    static member public PublicMethod() = ()
+    static member internal InternalMethod() = ()
+    static member private PrivateMethod() = ()
+    static member DefaultMethod() = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+    .method public hidebysig instance void 
+            PublicMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig instance void 
+            InternalMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method private hidebysig instance void 
+            PrivateMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig instance void 
+            DefaultMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+"""
+            else
+                """
+    .method public hidebysig instance void 
+            PublicMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig instance void 
+            InternalMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig instance void 
+            PrivateMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig instance void 
+            DefaultMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+"""
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - various static methods`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    static member public PublicMethod() = ()
+    static member internal InternalMethod() = ()
+    static member private PrivateMethod() = ()
+    static member DefaultMethod() = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+    .method public hidebysig instance void 
+            PublicMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig instance void 
+            InternalMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method private hidebysig instance void 
+            PrivateMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig instance void 
+            DefaultMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+"""
+            else
+                """
+    .method public hidebysig instance void 
+            PublicMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig instance void 
+            InternalMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig instance void 
+            PrivateMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig instance void 
+            DefaultMethod() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+"""
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - various static properties`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    static member val public PublicProperty = 0 with get, set
+    static member val internal InternalProperty = 0 with get, set
+    static member val private PrivateProperty = 0 with get, set
+    static member val DefaultProperty = 0 with get, set"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+    .me  thod public specialname static int32 
+            get_PublicProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 RealInternalSignature/TestType::init@4
+      IL_0007:  ldc.i4.1
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldsfld     int32 RealInternalSignature/TestType::PublicProperty@
+      IL_0016:  ret
+    } 
+
+    .method public specialname static void 
+            set_PublicProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 RealInternalSignature/TestType::init@4
+      IL_0007:  ldc.i4.1
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldarg.0
+      IL_0012:  stsfld     int32 RealInternalSignature/TestType::PublicProperty@
+      IL_0017:  ret
+    } 
+
+    .method assembly specialname static int32 
+            get_InternalProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 RealInternalSignature/TestType::init@4
+      IL_0007:  ldc.i4.2
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldsfld     int32 RealInternalSignature/TestType::InternalProperty@
+      IL_0016:  ret
+    } 
+
+    .method assembly specialname static void 
+            set_InternalProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 RealInternalSignature/TestType::init@4
+      IL_0007:  ldc.i4.2
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldarg.0
+      IL_0012:  stsfld     int32 RealInternalSignature/TestType::InternalProperty@
+      IL_0017:  ret
+    } 
+
+    .method private specialname static int32 
+            get_PrivateProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 RealInternalSignature/TestType::init@4
+      IL_0007:  ldc.i4.3
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldsfld     int32 RealInternalSignature/TestType::PrivateProperty@
+      IL_0016:  ret
+    } 
+
+    .method private specialname static void 
+            set_PrivateProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 RealInternalSignature/TestType::init@4
+      IL_0007:  ldc.i4.3
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldarg.0
+      IL_0012:  stsfld     int32 RealInternalSignature/TestType::PrivateProperty@
+      IL_0017:  ret
+    } 
+
+    .method public specialname static int32 
+            get_DefaultProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 RealInternalSignature/TestType::init@4
+      IL_0007:  ldc.i4.4
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldsfld     int32 RealInternalSignature/TestType::DefaultProperty@
+      IL_0016:  ret
+    } 
+
+    .method public specialname static void 
+            set_DefaultProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 RealInternalSignature/TestType::init@4
+      IL_0007:  ldc.i4.4
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldarg.0
+      IL_0012:  stsfld     int32 RealInternalSignature/TestType::DefaultProperty@
+      IL_0017:  ret
+    } 
+"""
+            else
+                """
+    .method public specialname static int32 
+            get_PublicProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 RealInternalSignature/TestType::init@4
+      IL_0007:  ldc.i4.1
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldsfld     int32 RealInternalSignature/TestType::PublicProperty@
+      IL_0016:  ret
+    } 
+
+    .method public specialname static void 
+            set_PublicProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 RealInternalSignature/TestType::init@4
+      IL_0007:  ldc.i4.1
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldarg.0
+      IL_0012:  stsfld     int32 RealInternalSignature/TestType::PublicProperty@
+      IL_0017:  ret
+    } 
+
+    .method assembly specialname static int32 
+            get_InternalProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 RealInternalSignature/TestType::init@4
+      IL_0007:  ldc.i4.2
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldsfld     int32 RealInternalSignature/TestType::InternalProperty@
+      IL_0016:  ret
+    } 
+
+    .method assembly specialname static void 
+            set_InternalProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 RealInternalSignature/TestType::init@4
+      IL_0007:  ldc.i4.2
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldarg.0
+      IL_0012:  stsfld     int32 RealInternalSignature/TestType::InternalProperty@
+      IL_0017:  ret
+    } 
+
+    .method assembly specialname static int32 
+            get_PrivateProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 RealInternalSignature/TestType::init@4
+      IL_0007:  ldc.i4.3
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldsfld     int32 RealInternalSignature/TestType::PrivateProperty@
+      IL_0016:  ret
+    } 
+
+    .method assembly specialname static void 
+            set_PrivateProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 RealInternalSignature/TestType::init@4
+      IL_0007:  ldc.i4.3
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldarg.0
+      IL_0012:  stsfld     int32 RealInternalSignature/TestType::PrivateProperty@
+      IL_0017:  ret
+    } 
+
+    .method public specialname static int32 
+            get_DefaultProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 RealInternalSignature/TestType::init@4
+      IL_0007:  ldc.i4.4
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldsfld     int32 RealInternalSignature/TestType::DefaultProperty@
+      IL_0016:  ret
+    } 
+
+    .method public specialname static void 
+            set_DefaultProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 RealInternalSignature/TestType::init@4
+      IL_0007:  ldc.i4.4
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldarg.0
+      IL_0012:  stsfld     int32 RealInternalSignature/TestType::DefaultProperty@
+      IL_0017:  ret
+    } 
+"""
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - various static properties`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type private TestType () =
+    static member val public PublicProperty = 0 with get, set
+    static member val internal InternalProperty = 0 with get, set
+    static member val private PrivateProperty = 0 with get, set
+    static member val DefaultProperty = 0 with get, set"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+    .method public hidebysig specialname 
+            instance int32  get_PublicProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::PublicProperty@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_PublicProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::PublicProperty@
+      IL_0007:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_InternalProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::InternalProperty@
+      IL_0006:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_InternalProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::InternalProperty@
+      IL_0007:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance int32  get_PrivateProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::PrivateProperty@
+      IL_0006:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance void  set_PrivateProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::PrivateProperty@
+      IL_0007:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_DefaultProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::DefaultProperty@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_DefaultProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::DefaultProperty@
+      IL_0007:  ret
+    } 
+"""
+            else
+                """
+    .method public hidebysig specialname 
+            instance int32  get_PublicProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::PublicProperty@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_PublicProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::PublicProperty@
+      IL_0007:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_InternalProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::InternalProperty@
+      IL_0006:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_InternalProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::InternalProperty@
+      IL_0007:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_PrivateProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::PrivateProperty@
+      IL_0006:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_PrivateProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::PrivateProperty@
+      IL_0007:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_DefaultProperty() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 RealInternalSignature/TestType::DefaultProperty@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_DefaultProperty(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 RealInternalSignature/TestType::DefaultProperty@
+      IL_0007:  ret
+    } 
+"""
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - various static mixed properties`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    static member MixedPropertyOne with public get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyTwo with public get() = 0 and private set (_:int) = ()
+    static member MixedPropertyThree with private get() = 0 and public set (_:int) = ()
+    static member MixedPropertyFour with private get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyFive with internal get() = 0 and public set (_:int) = ()
+    static member MixedPropertySix with internal get() = 0 and private set (_:int) = ()
+    static member MixedPropertySeven with get() = 0 and public set (_:int) = ()
+    static member MixedPropertyEight with get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyNine with get() = 0 and private set (_:int) = ()
+    static member MixedPropertyTen with public get() = 0 and set (_:int) = ()
+    static member MixedPropertyEleven with internal get() = 0 and set (_:int) = ()
+    static member MixedPropertyTwelve with private get() = 0 and set (_:int) = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyOne() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyOne(int32 _arg1) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyTwo() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance void  set_MixedPropertyTwo(int32 _arg2) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance int32  get_MixedPropertyThree() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyThree(int32 _arg3) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance int32  get_MixedPropertyFour() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyFour(int32 _arg4) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyFive() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyFive(int32 _arg5) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertySix() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance void  set_MixedPropertySix(int32 _arg6) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertySeven() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertySeven(int32 _arg7) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyEight() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyEight(int32 _arg8) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyNine() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance void  set_MixedPropertyNine(int32 _arg9) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyTen() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyTen(int32 _arg10) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyEleven() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyEleven(int32 _arg11) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance int32  get_MixedPropertyTwelve() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+"""
+            else
+                """
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyOne() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyOne(int32 _arg1) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyTwo() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyTwo(int32 _arg2) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyThree() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyThree(int32 _arg3) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyFour() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyFour(int32 _arg4) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyFive() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyFive(int32 _arg5) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertySix() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertySix(int32 _arg6) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertySeven() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertySeven(int32 _arg7) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyEight() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyEight(int32 _arg8) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyNine() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyNine(int32 _arg9) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance int32  get_MixedPropertyTen() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyTen(int32 _arg10) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyEleven() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyEleven(int32 _arg11) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyTwelve() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method public hidebysig specialname 
+            instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+"""
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - various static mixed properties`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type private TestType () =
+    static member MixedPropertyOne with public get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyTwo with public get() = 0 and private set (_:int) = ()
+    static member MixedPropertyThree with private get() = 0 and public set (_:int) = ()
+    static member MixedPropertyFour with private get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyFive with internal get() = 0 and public set (_:int) = ()
+    static member MixedPropertySix with internal get() = 0 and private set (_:int) = ()
+    static member MixedPropertySeven with get() = 0 and public set (_:int) = ()
+    static member MixedPropertyEight with get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyNine with get() = 0 and private set (_:int) = ()
+    static member MixedPropertyTen with public get() = 0 and set (_:int) = ()
+    static member MixedPropertyEleven with internal get() = 0 and set (_:int) = ()
+    static member MixedPropertyTwelve with private get() = 0 and set (_:int) = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyOne() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyOne(int32 _arg1) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyTwo() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance void  set_MixedPropertyTwo(int32 _arg2) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance int32  get_MixedPropertyThree() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyThree(int32 _arg3) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance int32  get_MixedPropertyFour() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyFour(int32 _arg4) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyFive() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyFive(int32 _arg5) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertySix() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance void  set_MixedPropertySix(int32 _arg6) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertySeven() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertySeven(int32 _arg7) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyEight() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyEight(int32 _arg8) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyNine() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance void  set_MixedPropertyNine(int32 _arg9) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyTen() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyTen(int32 _arg10) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyEleven() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyEleven(int32 _arg11) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method private hidebysig specialname 
+            instance int32  get_MixedPropertyTwelve() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+"""
+            else
+                """
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyOne() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyOne(int32 _arg1) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyTwo() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyTwo(int32 _arg2) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyThree() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyThree(int32 _arg3) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyFour() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyFour(int32 _arg4) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyFive() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyFive(int32 _arg5) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertySix() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertySix(int32 _arg6) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertySeven() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertySeven(int32 _arg7) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyEight() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyEight(int32 _arg8) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyNine() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyNine(int32 _arg9) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyTen() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyTen(int32 _arg10) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyEleven() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyEleven(int32 _arg11) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance int32  get_MixedPropertyTwelve() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ret
+    } 
+
+    .method assembly hidebysig specialname 
+            instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ret
+    } 
+"""
+
+            ]
+        |> shouldSucceed
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeVisibilityModuleRoot.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeVisibilityModuleRoot.fs
new file mode 100644
index 00000000000..318a5f3a7cb
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeVisibilityModuleRoot.fs
@@ -0,0 +1,880 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace EmittedIL.RealInternalSignature
+
+open Xunit
+open FSharp.Test
+open FSharp.Test.Compiler
+
+module ClassTypeVisibilityModuleRoot =
+
+    let withRealInternalSignature realSig compilation =
+        compilation
+        |> withOptions [if realSig then "--realsig+" else "--realsig-" ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - constructors`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TypeOne public () = class end
+type public TypeTwo internal () = class end
+type public TypeThree private () = class end
+type public TypeFour () = class end
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """  .class auto ansi serializable nested public TypeOne
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed"""
+
+                """  .class auto ansi serializable nested public TypeTwo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed"""
+
+                """  .class auto ansi serializable nested public TypeThree
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method private specialname rtspecialname instance void  .ctor() cil managed"""
+
+                """  .class auto ansi serializable nested public TypeFour
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed"""
+
+            else
+                """  .class auto ansi serializable nested public TypeOne
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed"""
+
+                """  .class auto ansi serializable nested public TypeTwo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed"""
+
+                """  .class auto ansi serializable nested public TypeThree
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed"""
+
+                """  .class auto ansi serializable nested public TypeFour
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed"""
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Private Type - constructors`` (realSig) =
+        FSharp """
+module MyLibrary
+type private TypeOne public () = class end
+type private TypeTwo internal () = class end
+type private TypeThree private () = class end
+type private TypeFour () = class end"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+  .class auto ansi serializable nested private TypeOne
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  }"""
+
+                """
+  .class auto ansi serializable nested private TypeTwo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } """
+
+                """
+  .class auto ansi serializable nested private TypeThree
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } """
+                """
+  .class auto ansi serializable nested private TypeFour
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } """
+            else
+                """
+  .class auto ansi serializable nested assembly TypeOne
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  }"""
+
+                """
+  .class auto ansi serializable nested assembly TypeTwo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } """
+
+                """
+  .class auto ansi serializable nested assembly TypeThree
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } """
+                """
+  .class auto ansi serializable nested assembly TypeFour
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } """
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - instance methods`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    member public _.PublicMethod() = ()
+    member internal _.InternalMethod() = ()
+    member private _.PrivateMethod() = ()
+    member _.DefaultMethod() = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig instance void PublicMethod() cil managed"
+                ".method assembly hidebysig instance void InternalMethod() cil managed"
+                ".method private hidebysig instance void PrivateMethod() cil managed"
+                ".method public hidebysig instance void DefaultMethod() cil managed"
+            else
+                ".method public hidebysig instance void PublicMethod() cil managed"
+                ".method assembly hidebysig instance void InternalMethod() cil managed"
+                ".method assembly hidebysig instance void PrivateMethod() cil managed"
+                ".method public hidebysig instance void DefaultMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - instance methods`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    member public _.PublicMethod() = ()
+    member internal _.InternalMethod() = ()
+    member private _.PrivateMethod() = ()
+    member _.DefaultMethod() = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig instance void PublicMethod() cil managed"
+                ".method assembly hidebysig instance void InternalMethod() cil managed"
+                ".method private hidebysig instance void PrivateMethod() cil managed"
+                ".method public hidebysig instance void DefaultMethod() cil managed"
+
+            else
+                ".method public hidebysig instance void PublicMethod() cil managed"
+                ".method assembly hidebysig instance void InternalMethod() cil managed"
+                ".method assembly hidebysig instance void PrivateMethod() cil managed"
+                ".method public hidebysig instance void DefaultMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - instance properties`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    member val public PublicProperty = 0 with get, set
+    member val internal InternalProperty = 0 with get, set
+    member val private PrivateProperty = 0 with get, set
+    member val DefaultProperty = 0 with get, set
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig specialname instance int32  get_PublicProperty() cil managed"
+                ".method public hidebysig specialname instance void  set_PublicProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_InternalProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_InternalProperty(int32 v) cil managed"
+                ".method private hidebysig specialname instance int32  get_PrivateProperty() cil managed"
+                ".method private hidebysig specialname instance void  set_PrivateProperty(int32 v) cil managed"
+                ".method public hidebysig specialname instance int32  get_DefaultProperty() cil managed"
+                ".method public hidebysig specialname instance void  set_DefaultProperty(int32 v) cil managed"
+
+            else
+                ".method public hidebysig specialname instance int32  get_PublicProperty() cil managed"
+                ".method public hidebysig specialname instance void  set_PublicProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_InternalProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_InternalProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_PrivateProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_PrivateProperty(int32 v) cil managed"
+                ".method public hidebysig specialname instance int32  get_DefaultProperty() cil managed"
+                ".method public hidebysig specialname instance void  set_DefaultProperty(int32 v) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - instance properties`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    member val public PublicProperty = 0 with get, set
+    member val internal InternalProperty = 0 with get, set
+    member val private PrivateProperty = 0 with get, set
+    member val DefaultProperty = 0 with get, set
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig specialname instance int32  get_PublicProperty() cil managed"
+                ".method public hidebysig specialname instance void  set_PublicProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_InternalProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_InternalProperty(int32 v) cil managed"
+                ".method private hidebysig specialname instance int32  get_PrivateProperty() cil managed"
+                ".method private hidebysig specialname instance void  set_PrivateProperty(int32 v) cil managed"
+                ".method public hidebysig specialname instance int32  get_DefaultProperty() cil managed"
+                ".method public hidebysig specialname instance void  set_DefaultProperty(int32 v) cil managed"
+
+            else
+                ".method public hidebysig specialname instance int32  get_PublicProperty() cil managed"
+                ".method public hidebysig specialname instance void  set_PublicProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_InternalProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_InternalProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_PrivateProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_PrivateProperty(int32 v) cil managed"
+                ".method public hidebysig specialname instance int32  get_DefaultProperty() cil managed"
+                ".method public hidebysig specialname instance void  set_DefaultProperty(int32 v) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - instance mixed properties`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    member _.MixedPropertyOne with public get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyTwo with public get() = 0 and private set (_:int) = ()
+    member _.MixedPropertyThree with private get() = 0 and public set (_:int) = ()
+    member _.MixedPropertyFour with private get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyFive with internal get() = 0 and public set (_:int) = ()
+    member _.MixedPropertySix with internal get() = 0 and private set (_:int) = ()
+    member _.MixedPropertySeven with get() = 0 and public set (_:int) = ()
+    member _.MixedPropertyEight with get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyNine with get() = 0 and private set (_:int) = ()
+    member _.MixedPropertyTen with public get() = 0 and set (_:int) = ()
+    member _.MixedPropertyEleven with internal get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTwelve with private get() = 0 and set (_:int) = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig specialname instance int32  get_MixedPropertyOne() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyTwo() cil managed"
+                ".method private hidebysig specialname instance void  set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method private hidebysig specialname instance int32  get_MixedPropertyThree() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method private hidebysig specialname instance int32  get_MixedPropertyFour() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFive() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySix() cil managed"
+                ".method private hidebysig specialname instance void  set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertySeven() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyEight() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyNine() cil managed"
+                ".method private hidebysig specialname instance void  set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyTen() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEleven() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method private hidebysig specialname instance int32  get_MixedPropertyTwelve() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            else
+                ".method public hidebysig specialname instance int32  get_MixedPropertyOne() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyTwo() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyThree() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFour() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFive() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySix() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertySeven() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyEight() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyNine() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyTen() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEleven() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyTwelve() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - instance mixed properties`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type private TestType () =
+    member _.MixedPropertyOne with public get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyTwo with public get() = 0 and private set (_:int) = ()
+    member _.MixedPropertyThree with private get() = 0 and public set (_:int) = ()
+    member _.MixedPropertyFour with private get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyFive with internal get() = 0 and public set (_:int) = ()
+    member _.MixedPropertySix with internal get() = 0 and private set (_:int) = ()
+    member _.MixedPropertySeven with get() = 0 and public set (_:int) = ()
+    member _.MixedPropertyEight with get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyNine with get() = 0 and private set (_:int) = ()
+    member _.MixedPropertyTen with public get() = 0 and set (_:int) = ()
+    member _.MixedPropertyEleven with internal get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTwelve with private get() = 0 and set (_:int) = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig specialname instance int32  get_MixedPropertyOne() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyTwo() cil managed"
+                ".method private hidebysig specialname instance void  set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method private hidebysig specialname instance int32  get_MixedPropertyThree() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method private hidebysig specialname instance int32  get_MixedPropertyFour() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFive() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySix() cil managed"
+                ".method private hidebysig specialname instance void  set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertySeven() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyEight() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyNine() cil managed"
+                ".method private hidebysig specialname instance void  set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyTen() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEleven() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method private hidebysig specialname instance int32  get_MixedPropertyTwelve() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            else
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyOne() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyTwo() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyThree() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFour() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFive() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySix() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySeven() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEight() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyNine() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyTen() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEleven() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyTwelve() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - static methods`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    static member public PublicMethod() = ()
+    static member internal InternalMethod() = ()
+    static member private PrivateMethod() = ()
+    static member DefaultMethod() = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method private static void  PrivateMethod() cil managed"
+                ".method public static void  DefaultMethod() cil managed"
+
+            else
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method assembly static void  PrivateMethod() cil managed"
+                ".method public static void  DefaultMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - static methods`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type private TestType () =
+    static member public PublicMethod() = ()
+    static member internal InternalMethod() = ()
+    static member private PrivateMethod() = ()
+    static member DefaultMethod() = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method private static void  PrivateMethod() cil managed"
+                ".method public static void  DefaultMethod() cil managed"
+
+            else
+                ".method assembly static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method assembly static void  PrivateMethod() cil managed"
+                ".method assembly static void  DefaultMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - static properties`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    static member val public PublicProperty = 0 with get, set
+    static member val internal InternalProperty = 0 with get, set
+    static member val private PrivateProperty = 0 with get, set
+    static member val DefaultProperty = 0 with get, set"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname static int32 get_PublicProperty() cil managed"
+                ".method public specialname static void set_PublicProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_InternalProperty() cil managed"
+                ".method assembly specialname static void set_InternalProperty(int32 v) cil managed"
+                ".method private specialname static int32 get_PrivateProperty() cil managed"
+                ".method private specialname static void set_PrivateProperty(int32 v) cil managed"
+                ".method public specialname static int32 get_DefaultProperty() cil managed"
+                ".method public specialname static void set_DefaultProperty(int32 v) cil managed"
+            else
+                ".method public specialname static int32 get_PublicProperty() cil managed"
+                ".method public specialname static void set_PublicProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_InternalProperty() cil managed"
+                ".method assembly specialname static void set_InternalProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_PrivateProperty() cil managed"
+                ".method assembly specialname static void set_PrivateProperty(int32 v) cil managed"
+                ".method public specialname static int32 get_DefaultProperty() cil managed"
+                ".method public specialname static void set_DefaultProperty(int32 v) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - static properties`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type private TestType () =
+    static member val public PublicProperty = 0 with get, set
+    static member val internal InternalProperty = 0 with get, set
+    static member val private PrivateProperty = 0 with get, set
+    static member val DefaultProperty = 0 with get, set"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname static int32 get_PublicProperty() cil managed"
+                ".method public specialname static void set_PublicProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_InternalProperty() cil managed"
+                ".method assembly specialname static void set_InternalProperty(int32 v) cil managed"
+                ".method private specialname static int32 get_PrivateProperty() cil managed"
+                ".method private specialname static void set_PrivateProperty(int32 v) cil managed"
+                ".method public specialname static int32 get_DefaultProperty() cil managed"
+                ".method public specialname static void set_DefaultProperty(int32 v) cil managed"
+
+            else
+                ".method assembly specialname static int32 get_PublicProperty() cil managed"
+                ".method assembly specialname static void set_PublicProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_InternalProperty() cil managed"
+                ".method assembly specialname static int32 get_PrivateProperty() cil managed"
+                ".method assembly specialname static void set_PrivateProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_DefaultProperty() cil managed"
+                ".method assembly specialname static void set_DefaultProperty(int32 v) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - static mixed properties`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    static member MixedPropertyOne with public get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyTwo with public get() = 0 and private set (_:int) = ()
+    static member MixedPropertyThree with private get() = 0 and public set (_:int) = ()
+    static member MixedPropertyFour with private get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyFive with internal get() = 0 and public set (_:int) = ()
+    static member MixedPropertySix with internal get() = 0 and private set (_:int) = ()
+    static member MixedPropertySeven with get() = 0 and public set (_:int) = ()
+    static member MixedPropertyEight with get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyNine with get() = 0 and private set (_:int) = ()
+    static member MixedPropertyTen with public get() = 0 and set (_:int) = ()
+    static member MixedPropertyEleven with internal get() = 0 and set (_:int) = ()
+    static member MixedPropertyTwelve with private get() = 0 and set (_:int) = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname static int32 get_MixedPropertyOne() cil managed"
+                ".method assembly specialname static void set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTwo() cil managed"
+                ".method private specialname static void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method private specialname static int32 get_MixedPropertyThree() cil managed"
+                ".method public specialname static void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method private specialname static int32 get_MixedPropertyFour() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFive() cil managed"
+                ".method public specialname static void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySix() cil managed"
+                ".method private specialname static void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public specialname static int32 get_MixedPropertySeven() cil managed"
+                ".method public specialname static void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public specialname static int32 get_MixedPropertyEight() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public specialname static int32 get_MixedPropertyNine() cil managed"
+                ".method private specialname static void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTen() cil managed"
+                ".method public specialname static void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEleven() cil managed"
+                ".method public specialname static void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method private specialname static int32 get_MixedPropertyTwelve() cil managed"
+                ".method public specialname static void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            else
+                ".method public specialname static int32 get_MixedPropertyOne() cil managed"
+                ".method assembly specialname static void set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTwo() cil managed"
+                ".method assembly specialname static void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyThree() cil managed"
+                ".method public specialname static void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFour() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFive() cil managed"
+                ".method public specialname static void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySix() cil managed"
+                ".method assembly specialname static void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public specialname static int32 get_MixedPropertySeven() cil managed"
+                ".method public specialname static void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public specialname static int32 get_MixedPropertyEight() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public specialname static int32 get_MixedPropertyNine() cil managed"
+                ".method assembly specialname static void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTen() cil managed"
+                ".method public specialname static void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEleven() cil managed"
+                ".method public specialname static void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyTwelve() cil managed"
+                ".method public specialname static void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - static mixed properties`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type private TestType () =
+    static member MixedPropertyOne with public get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyTwo with public get() = 0 and private set (_:int) = ()
+    static member MixedPropertyThree with private get() = 0 and public set (_:int) = ()
+    static member MixedPropertyFour with private get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyFive with internal get() = 0 and public set (_:int) = ()
+    static member MixedPropertySix with internal get() = 0 and private set (_:int) = ()
+    static member MixedPropertySeven with get() = 0 and public set (_:int) = ()
+    static member MixedPropertyEight with get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyNine with get() = 0 and private set (_:int) = ()
+    static member MixedPropertyTen with public get() = 0 and set (_:int) = ()
+    static member MixedPropertyEleven with internal get() = 0 and set (_:int) = ()
+    static member MixedPropertyTwelve with private get() = 0 and set (_:int) = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname static int32 get_MixedPropertyOne() cil managed"
+                ".method assembly specialname static void set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTwo() cil managed"
+                ".method private specialname static void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method private specialname static int32 get_MixedPropertyThree() cil managed"
+                ".method public specialname static void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method private specialname static int32 get_MixedPropertyFour() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFive() cil managed"
+                ".method public specialname static void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySix() cil managed"
+                ".method private specialname static void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public specialname static int32 get_MixedPropertySeven() cil managed"
+                ".method public specialname static void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public specialname static int32 get_MixedPropertyEight() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public specialname static int32 get_MixedPropertyNine() cil managed"
+                ".method private specialname static void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTen() cil managed"
+                ".method public specialname static void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEleven() cil managed"
+                ".method public specialname static void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method private specialname static int32 get_MixedPropertyTwelve() cil managed"
+                ".method public specialname static void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            else
+                ".method assembly specialname static int32 get_MixedPropertyOne() cil managed"
+                ".method assembly specialname static void set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyTwo() cil managed"
+                ".method assembly specialname static void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyThree() cil managed"
+                ".method assembly specialname static void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFour() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFive() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySix() cil managed"
+                ".method assembly specialname static void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySeven() cil managed"
+                ".method assembly specialname static void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEight() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyNine() cil managed"
+                ".method assembly specialname static void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyTen() cil managed"
+                ".method assembly specialname static void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEleven() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyTwelve() cil managed"
+                ".method assembly specialname static void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true, "private")>]        // RealSig
+    [<InlineData(false, "private")>]       // Regular
+    [<InlineData(true, "internal")>]        // RealSig
+    [<InlineData(false, "internal")>]       // Regular
+    [<InlineData(true, "public")>]        // RealSig
+    [<InlineData(false, "public")>]       // Regular
+    [<Theory>]
+    let ``lazy operation - member with various visibilities`` (realSig, scope) =
+        FSharp $"""
+module internal SR =
+    let {scope} lazyThing = lazy ( () )
+    let getLazyThing () = lazyThing.Force()
+SR.getLazyThing ()
+"""
+        |> asExe
+        |> withLangVersionPreview
+        |> withOptimize
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeVisibilityModuleRootWithFsi.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeVisibilityModuleRootWithFsi.fs
new file mode 100644
index 00000000000..4d7d55c1e8e
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeVisibilityModuleRootWithFsi.fs
@@ -0,0 +1,1251 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace EmittedIL.RealInternalSignature
+
+open Xunit
+open FSharp.Test.Compiler
+
+module ClassTypeVisibilityModuleRootWithFsi =
+
+    let withRealInternalSignature realSig compilation =
+        compilation
+        |> withOptions [if realSig then "--realsig+" else "--realsig-" ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - constructors`` (realSig) =
+        Fsi """
+module RealInternalSignature
+
+type public TypeOne = public new: unit -> TypeOne
+type public TypeTwo = internal new: unit -> TypeTwo
+type public TypeThree = private new: unit -> TypeThree
+type public TypeFour = public new: unit -> TypeFour
+"""
+        |> withAdditionalSourceFile (FsSource ("""
+module RealInternalSignature
+
+type TypeOne () = class end
+type TypeTwo () = class end
+type TypeThree () = class end
+type TypeFour () = class end
+type HiddenType () = class end
+        """))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+.class auto ansi serializable nested public TypeOne
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+} 
+"""
+
+                """
+.class auto ansi serializable nested public TypeTwo
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method assembly specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+} 
+"""
+
+                """
+.class auto ansi serializable nested public TypeThree
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method private specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+} 
+"""
+
+                """
+.class auto ansi serializable nested public TypeFour
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+} 
+"""
+
+                """
+  .class auto ansi serializable nested assembly HiddenType
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  }"""
+
+            else
+                """
+.class auto ansi serializable nested public TypeOne
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+} 
+"""
+
+                """
+.class auto ansi serializable nested public TypeTwo
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method assembly specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+} 
+"""
+
+                """
+.class auto ansi serializable nested public TypeThree
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method assembly specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+} 
+"""
+
+                """
+.class auto ansi serializable nested public TypeFour
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+} 
+"""
+
+                """
+  .class auto ansi serializable nested assembly HiddenType
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } """
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - constructors`` (realSig) =
+        Fsi """
+module RealInternalSignature
+
+type private TypeOne = public new: unit -> TypeOne
+type private TypeTwo = internal new: unit -> TypeTwo
+type private TypeThree = private new: unit -> TypeThree
+type private TypeFour = public new: unit -> TypeFour
+"""
+        |> withAdditionalSourceFile (FsSource ("""
+module RealInternalSignature
+
+type TypeOne () = class end
+type TypeTwo () = class end
+type TypeThree () = class end
+type TypeFour () = class end
+type HiddenType () = class end
+        """))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+  .class auto ansi serializable nested private TypeOne
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  }"""
+
+                """
+  .class auto ansi serializable nested private TypeTwo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } """
+
+                """
+  .class auto ansi serializable nested private TypeThree
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } """
+                """
+  .class auto ansi serializable nested private TypeFour
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } """
+
+                """
+  .class auto ansi serializable nested assembly HiddenType
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } """
+
+            else
+                """
+  .class auto ansi serializable nested assembly TypeOne
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  }"""
+
+                """
+  .class auto ansi serializable nested assembly TypeTwo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } """
+
+                """
+  .class auto ansi serializable nested assembly TypeThree
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } """
+                """
+  .class auto ansi serializable nested assembly TypeFour
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } """
+
+                """
+  .class auto ansi serializable nested assembly HiddenType
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+  } """
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - instance methods`` (realSig) =
+        Fsi """
+module RealInternalSignature
+    type public TestType =
+        new: unit -> TestType
+        member DefaultMethod: unit -> unit
+        member internal InternalMethod: unit -> unit
+        member private PrivateMethod: unit -> unit
+        member PublicMethod: unit -> unit"""
+        |> withAdditionalSourceFile (FsSource ("""
+module RealInternalSignature
+
+type TestType () =
+    member _.PublicMethod() = ()
+    member _.InternalMethod() = ()
+    member _.PrivateMethod() = ()
+    member _.DefaultMethod() = ()
+    member _.HiddenMethod() = ()"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig instance void PublicMethod() cil managed"
+                ".method assembly hidebysig instance void InternalMethod() cil managed"
+                ".method private hidebysig instance void PrivateMethod() cil managed"
+                ".method public hidebysig instance void DefaultMethod() cil managed"
+                ".method assembly hidebysig instance void HiddenMethod() cil managed"
+            else
+                ".method public hidebysig instance void PublicMethod() cil managed"
+                ".method assembly hidebysig instance void InternalMethod() cil managed"
+                ".method assembly hidebysig instance void PrivateMethod() cil managed"
+                ".method public hidebysig instance void DefaultMethod() cil managed"
+                ".method assembly hidebysig instance void HiddenMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - instance methods`` (realSig) =
+        Fsi """
+module RealInternalSignature
+    type private TestType =
+        new: unit -> TestType
+        member DefaultMethod: unit -> unit
+        member internal InternalMethod: unit -> unit
+        member private PrivateMethod: unit -> unit
+        member PublicMethod: unit -> unit"""
+        |> withAdditionalSourceFile (FsSource ("""
+module RealInternalSignature
+
+type TestType () =
+    member _.PublicMethod() = ()
+    member _.InternalMethod() = ()
+    member _.PrivateMethod() = ()
+    member _.DefaultMethod() = ()
+    member _.HiddenMethod() = ()"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig instance void PublicMethod() cil managed"
+                ".method assembly hidebysig instance void InternalMethod() cil managed"
+                ".method private hidebysig instance void PrivateMethod() cil managed"
+                ".method public hidebysig instance void DefaultMethod() cil managed"
+
+            else
+                ".method assembly hidebysig instance void PublicMethod() cil managed"
+                ".method assembly hidebysig instance void InternalMethod() cil managed"
+                ".method assembly hidebysig instance void PrivateMethod() cil managed"
+                ".method assembly hidebysig instance void DefaultMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - instance properties`` (realSig) =
+        Fsi """
+module RealInternalSignature
+type public TestType =
+    new: unit -> TestType
+    member public PublicProperty: int with get
+    member public PublicProperty: int with set
+    member internal InternalProperty: int with get
+    member internal InternalProperty: int with set
+    member private PrivateProperty: int with get
+    member private PrivateProperty: int with set
+    member DefaultProperty: int with get
+    member DefaultProperty: int with set"""
+        |> withAdditionalSourceFile (FsSource ("""
+module RealInternalSignature
+
+type TestType () =
+    member val PublicProperty = 0 with get, set
+    member val InternalProperty = 0 with get, set
+    member val PrivateProperty = 0 with get, set
+    member val DefaultProperty = 0 with get, set"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig specialname instance int32  get_PublicProperty() cil managed"
+                ".method public hidebysig specialname instance void  set_PublicProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_InternalProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_InternalProperty(int32 v) cil managed"
+                ".method private hidebysig specialname instance int32  get_PrivateProperty() cil managed"
+                ".method private hidebysig specialname instance void  set_PrivateProperty(int32 v) cil managed"
+                ".method public hidebysig specialname instance int32  get_DefaultProperty() cil managed"
+                ".method public hidebysig specialname instance void  set_DefaultProperty(int32 v) cil managed"
+
+            else
+                ".method public hidebysig specialname instance int32  get_PublicProperty() cil managed"
+                ".method public hidebysig specialname instance void  set_PublicProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_InternalProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_InternalProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_PrivateProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_PrivateProperty(int32 v) cil managed"
+                ".method public hidebysig specialname instance int32  get_DefaultProperty() cil managed"
+                ".method public hidebysig specialname instance void  set_DefaultProperty(int32 v) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - instance properties`` (realSig) =
+        Fsi """
+module RealInternalSignature
+type private TestType =
+    new: unit -> TestType
+    member public PublicProperty: int with get
+    member public PublicProperty: int with set
+    member internal InternalProperty: int with get
+    member internal InternalProperty: int with set
+    member private PrivateProperty: int with get
+    member private PrivateProperty: int with set
+    member DefaultProperty: int with get
+    member DefaultProperty: int with set"""
+        |> withAdditionalSourceFile (FsSource ("""
+module RealInternalSignature
+
+type TestType () =
+    member val PublicProperty = 0 with get, set
+    member val InternalProperty = 0 with get, set
+    member val PrivateProperty = 0 with get, set
+    member val DefaultProperty = 0 with get, set
+    member val HiddenProperty = 0 with get, set"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig specialname instance int32  get_PublicProperty() cil managed"
+                ".method public hidebysig specialname instance void  set_PublicProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_InternalProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_InternalProperty(int32 v) cil managed"
+                ".method private hidebysig specialname instance int32  get_PrivateProperty() cil managed"
+                ".method private hidebysig specialname instance void  set_PrivateProperty(int32 v) cil managed"
+                ".method public hidebysig specialname instance int32  get_DefaultProperty() cil managed"
+                ".method public hidebysig specialname instance void  set_DefaultProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_HiddenProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_HiddenProperty(int32 v) cil managed"
+
+            else
+                ".method assembly hidebysig specialname instance int32  get_PublicProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_PublicProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_InternalProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_InternalProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_PrivateProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_PrivateProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_DefaultProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_DefaultProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_HiddenProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_HiddenProperty(int32 v) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - instance mixed properties`` (realSig) =
+        Fsi """
+module RealInternalSignature
+    type TestType =
+        new: unit -> TestType
+        member public MixedPropertyOne: int with get
+        member internal MixedPropertyOne: int with set
+        member public MixedPropertyTwo: int with get
+        member private MixedPropertyTwo: int with set
+        member private MixedPropertyThree: int with get
+        member public MixedPropertyThree: int with set
+        member private MixedPropertyFour: int with get
+        member internal MixedPropertyFour: int with set
+        member internal MixedPropertyFive: int with get
+        member public MixedPropertyFive: int with set
+        member internal MixedPropertySix: int with get
+        member private MixedPropertySix: int with set
+        member public MixedPropertySeven: int with get
+        member public MixedPropertySeven: int with set
+        member public MixedPropertyEight: int with get
+        member internal MixedPropertyEight: int with set
+        member public MixedPropertyNine: int with get
+        member private MixedPropertyNine: int with set
+        member MixedPropertyTen: int with get
+        member MixedPropertyTen: int with set
+        member internal MixedPropertyEleven: int with get
+        member public MixedPropertyEleven: int with set
+        member private MixedPropertyTwelve: int with get
+        member public MixedPropertyTwelve: int with set"""
+        |> withAdditionalSourceFile (FsSource ("""
+module RealInternalSignature
+
+type public TestType () =
+    member _.MixedPropertyOne with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTwo with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyThree with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyFour with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyFive with get() = 0 and set (_:int) = ()
+    member _.MixedPropertySix with get() = 0 and set (_:int) = ()
+    member _.MixedPropertySeven with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyEight with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyNine with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTen with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyEleven with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTwelve with get() = 0 and set (_:int) = ()"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig specialname instance int32  get_MixedPropertyOne() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyTwo() cil managed"
+                ".method private hidebysig specialname instance void  set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method private hidebysig specialname instance int32  get_MixedPropertyThree() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method private hidebysig specialname instance int32  get_MixedPropertyFour() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFive() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySix() cil managed"
+                ".method private hidebysig specialname instance void  set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertySeven() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyEight() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyNine() cil managed"
+                ".method private hidebysig specialname instance void  set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyTen() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEleven() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method private hidebysig specialname instance int32  get_MixedPropertyTwelve() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            else
+                ".method public hidebysig specialname instance int32  get_MixedPropertyOne() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyTwo() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyThree() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFour() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFive() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySix() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertySeven() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyEight() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyNine() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyTen() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEleven() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyTwelve() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - instance mixed properties`` (realSig) =
+        Fsi """
+module RealInternalSignature
+    type private TestType =
+        new: unit -> TestType
+        member public MixedPropertyOne: int with get
+        member internal MixedPropertyOne: int with set
+        member public MixedPropertyTwo: int with get
+        member private MixedPropertyTwo: int with set
+        member private MixedPropertyThree: int with get
+        member public MixedPropertyThree: int with set
+        member private MixedPropertyFour: int with get
+        member internal MixedPropertyFour: int with set
+        member internal MixedPropertyFive: int with get
+        member public MixedPropertyFive: int with set
+        member internal MixedPropertySix: int with get
+        member private MixedPropertySix: int with set
+        member public MixedPropertySeven: int with get
+        member public MixedPropertySeven: int with set
+        member public MixedPropertyEight: int with get
+        member internal MixedPropertyEight: int with set
+        member public MixedPropertyNine: int with get
+        member private MixedPropertyNine: int with set
+        member public MixedPropertyTen: int with get
+        member public MixedPropertyTen: int with set
+        member internal MixedPropertyEleven: int with get
+        member public MixedPropertyEleven: int with set
+        member private MixedPropertyTwelve: int with get
+        member public MixedPropertyTwelve: int with set"""
+        |> withAdditionalSourceFile (FsSource ("""
+module RealInternalSignature
+
+type public TestType () =
+    member _.MixedPropertyOne with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTwo with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyThree with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyFour with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyFive with get() = 0 and set (_:int) = ()
+    member _.MixedPropertySix with get() = 0 and set (_:int) = ()
+    member _.MixedPropertySeven with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyEight with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyNine with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTen with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyEleven with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTwelve with get() = 0 and set (_:int) = ()"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig specialname instance int32  get_MixedPropertyOne() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyTwo() cil managed"
+                ".method private hidebysig specialname instance void  set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method private hidebysig specialname instance int32  get_MixedPropertyThree() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method private hidebysig specialname instance int32  get_MixedPropertyFour() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFive() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySix() cil managed"
+                ".method private hidebysig specialname instance void  set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertySeven() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyEight() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyNine() cil managed"
+                ".method private hidebysig specialname instance void  set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public hidebysig specialname instance int32  get_MixedPropertyTen() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEleven() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method private hidebysig specialname instance int32  get_MixedPropertyTwelve() cil managed"
+                ".method public hidebysig specialname instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed"
+            else
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyOne() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyTwo() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyThree() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFour() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFive() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySix() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySeven() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEight() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyNine() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyTen() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEleven() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyTwelve() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - static methods`` (realSig) =
+        Fsi """
+module RealInternalSignature
+    type public TestType =
+        new: unit -> TestType
+        static member DefaultMethod: unit -> unit
+        static member internal InternalMethod: unit -> unit
+        static member private PrivateMethod: unit -> unit
+        static member PublicMethod: unit -> unit"""
+        |> withAdditionalSourceFile (FsSource ("""
+module RealInternalSignature
+
+type TestType () =
+    static member PublicMethod() = ()
+    static member InternalMethod() = ()
+    static member PrivateMethod() = ()
+    static member DefaultMethod() = ()
+    static member HiddenMethod() = ()"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method private static void  PrivateMethod() cil managed"
+                ".method public static void  DefaultMethod() cil managed"
+                ".method assembly static void  HiddenMethod() cil managed"
+
+            else
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method assembly static void  PrivateMethod() cil managed"
+                ".method public static void  DefaultMethod() cil managed"
+                ".method assembly static void  HiddenMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - static methods`` (realSig) =
+        FSharp """
+module RealInternalSignature
+
+type public TestType () =
+    static member public PublicMethod() = ()
+    static member internal InternalMethod() = ()
+    static member private PrivateMethod() = ()
+    static member DefaultMethod() = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method private static void  PrivateMethod() cil managed"
+                ".method public static void  DefaultMethod() cil managed"
+
+            else
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method assembly static void  PrivateMethod() cil managed"
+                ".method public static void  DefaultMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - static properties`` (realSig) =
+        Fsi """
+module RealInternalSignature
+type public TestType =
+    new: unit -> TestType
+    static member public PublicProperty: int with get
+    static member public PublicProperty: int with set
+    static member internal InternalProperty: int with get
+    static member internal InternalProperty: int with set
+    static member private PrivateProperty: int with get
+    static member private PrivateProperty: int with set
+    static member DefaultProperty: int with get
+    static member DefaultProperty: int with set"""
+        |> withAdditionalSourceFile (FsSource ("""
+module RealInternalSignature
+
+type TestType () =
+    static member val PublicProperty = 0 with get, set
+    static member val InternalProperty = 0 with get, set
+    static member val PrivateProperty = 0 with get, set
+    static member val DefaultProperty = 0 with get, set
+    static member val HiddenProperty = 0 with get, set"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname static int32 get_PublicProperty() cil managed"
+                ".method public specialname static void set_PublicProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_InternalProperty() cil managed"
+                ".method assembly specialname static void set_InternalProperty(int32 v) cil managed"
+                ".method private specialname static int32 get_PrivateProperty() cil managed"
+                ".method private specialname static void set_PrivateProperty(int32 v) cil managed"
+                ".method public specialname static int32 get_DefaultProperty() cil managed"
+                ".method public specialname static void set_DefaultProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_HiddenProperty() cil managed"
+                ".method assembly specialname static void set_HiddenProperty(int32 v) cil managed"
+
+            else
+                ".method public specialname static int32 get_PublicProperty() cil managed"
+                ".method public specialname static void set_PublicProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_InternalProperty() cil managed"
+                ".method assembly specialname static void set_InternalProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_PrivateProperty() cil managed"
+                ".method assembly specialname static void set_PrivateProperty(int32 v) cil managed"
+                ".method public specialname static int32 get_DefaultProperty() cil managed"
+                ".method public specialname static void set_DefaultProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_HiddenProperty() cil managed"
+                ".method assembly specialname static void set_HiddenProperty(int32 v) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - static properties`` (realSig) =
+        Fsi """
+module RealInternalSignature
+type private TestType =
+    new: unit -> TestType
+    static member PublicProperty: int with get
+    static member PublicProperty: int with set
+    static member internal InternalProperty: int with get
+    static member internal InternalProperty: int with set
+    static member private PrivateProperty: int with get
+    static member private PrivateProperty: int with set
+    static member DefaultProperty: int with get
+    static member DefaultProperty: int with set"""
+        |> withAdditionalSourceFile (FsSource ("""
+module RealInternalSignature
+
+type TestType () =
+    static member val PublicProperty = 0 with get, set
+    static member val InternalProperty = 0 with get, set
+    static member val PrivateProperty = 0 with get, set
+    static member val DefaultProperty = 0 with get, set"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname static int32 get_PublicProperty() cil managed"
+                ".method public specialname static void set_PublicProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_InternalProperty() cil managed"
+                ".method assembly specialname static void set_InternalProperty(int32 v) cil managed"
+                ".method private specialname static int32 get_PrivateProperty() cil managed"
+                ".method private specialname static void set_PrivateProperty(int32 v) cil managed"
+                ".method public specialname static int32 get_DefaultProperty() cil managed"
+                ".method public specialname static void set_DefaultProperty(int32 v) cil managed"
+
+            else
+                ".method assembly specialname static int32 get_PublicProperty() cil managed"
+                ".method assembly specialname static void set_PublicProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_InternalProperty() cil managed"
+                ".method assembly specialname static void set_InternalProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_PrivateProperty() cil managed"
+                ".method assembly specialname static void set_PrivateProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_DefaultProperty() cil managed"
+                ".method assembly specialname static void set_DefaultProperty(int32 v) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - static mixed properties`` (realSig) =
+        Fsi """
+module RealInternalSignature
+    type public TestType =
+        new: unit -> TestType
+        static member public MixedPropertyOne: int with get
+        static member internal MixedPropertyOne: int with set
+        static member public MixedPropertyTwo: int with get        
+        static member private MixedPropertyTwo: int with set
+        static member private MixedPropertyThree: int with get
+        static member public MixedPropertyThree: int with set
+        static member private MixedPropertyFour: int with get
+        static member internal MixedPropertyFour: int with set
+        static member internal MixedPropertyFive: int with get
+        static member public MixedPropertyFive: int with set
+        static member internal MixedPropertySix: int with get
+        static member private MixedPropertySix: int with set
+        static member public MixedPropertySeven: int with get
+        static member public MixedPropertySeven: int with set
+        static member MixedPropertyEight: int with get
+        static member internal MixedPropertyEight: int with set
+        static member MixedPropertyNine: int with get
+        static member private MixedPropertyNine: int with set
+        static member MixedPropertyTen: int with get
+        static member MixedPropertyTen: int with set
+        static member internal MixedPropertyEleven: int with get
+        static member MixedPropertyEleven: int with set
+        static member private MixedPropertyTwelve: int with get
+        static member MixedPropertyTwelve: int with set
+"""
+        |> withAdditionalSourceFile (FsSource ("""
+module RealInternalSignature
+
+type public TestType () =
+    static member MixedPropertyOne with public get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyTwo with public get() = 0 and private set (_:int) = ()
+    static member MixedPropertyThree with private get() = 0 and public set (_:int) = ()
+    static member MixedPropertyFour with private get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyFive with internal get() = 0 and public set (_:int) = ()
+    static member MixedPropertySix with internal get() = 0 and private set (_:int) = ()
+    static member MixedPropertySeven with get() = 0 and public set (_:int) = ()
+    static member MixedPropertyEight with get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyNine with get() = 0 and private set (_:int) = ()
+    static member MixedPropertyTen with public get() = 0 and set (_:int) = ()
+    static member MixedPropertyEleven with internal get() = 0 and set (_:int) = ()
+    static member MixedPropertyTwelve with private get() = 0 and set (_:int) = ()"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname static int32 get_MixedPropertyOne() cil managed"
+                ".method assembly specialname static void set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTwo() cil managed"
+                ".method private specialname static void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method private specialname static int32 get_MixedPropertyThree() cil managed"
+                ".method public specialname static void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method private specialname static int32 get_MixedPropertyFour() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFive() cil managed"
+                ".method public specialname static void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySix() cil managed"
+                ".method private specialname static void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public specialname static int32 get_MixedPropertySeven() cil managed"
+                ".method public specialname static void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public specialname static int32 get_MixedPropertyEight() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public specialname static int32 get_MixedPropertyNine() cil managed"
+                ".method private specialname static void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTen() cil managed"
+                ".method public specialname static void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEleven() cil managed"
+                ".method public specialname static void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method private specialname static int32 get_MixedPropertyTwelve() cil managed"
+                ".method public specialname static void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            else
+                ".method public specialname static int32 get_MixedPropertyOne() cil managed"
+                ".method assembly specialname static void set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTwo() cil managed"
+                ".method assembly specialname static void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyThree() cil managed"
+                ".method public specialname static void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFour() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFive() cil managed"
+                ".method public specialname static void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySix() cil managed"
+                ".method assembly specialname static void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public specialname static int32 get_MixedPropertySeven() cil managed"
+                ".method public specialname static void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public specialname static int32 get_MixedPropertyEight() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public specialname static int32 get_MixedPropertyNine() cil managed"
+                ".method assembly specialname static void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTen() cil managed"
+                ".method public specialname static void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEleven() cil managed"
+                ".method public specialname static void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyTwelve() cil managed"
+                ".method public specialname static void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - static mixed properties`` (realSig) =
+        Fsi """
+module RealInternalSignature
+type private TestType =
+    new: unit -> TestType
+    static member public MixedPropertyOne: int with get
+    static member internal MixedPropertyOne: int with set
+    static member public MixedPropertyTwo: int with get
+    static member private MixedPropertyTwo: int with set
+    static member private MixedPropertyThree: int with get
+    static member public MixedPropertyThree: int with set
+    static member private MixedPropertyFour: int with get
+    static member internal MixedPropertyFour: int with set
+    static member internal MixedPropertyFive: int with get
+    static member public MixedPropertyFive: int with set
+    static member internal MixedPropertySix: int with get
+    static member private MixedPropertySix: int with set
+    static member MixedPropertySeven: int with get
+    static member MixedPropertySeven: int with set
+    static member public MixedPropertySeven: int with set
+    static member MixedPropertyEight: int with get
+    static member internal MixedPropertyEight: int with set
+    static member MixedPropertyNine: int with get
+    static member private MixedPropertyNine: int with set
+    static member MixedPropertyTen: int with get
+    static member MixedPropertyTen: int with set
+    static member internal MixedPropertyEleven: int with get
+    static member MixedPropertyEleven: int with set
+    static member private MixedPropertyTwelve: int with get
+    static member MixedPropertyTwelve: int with set
+"""
+        |> withAdditionalSourceFile (FsSource ("""
+module RealInternalSignature
+
+type private TestType () =
+    static member MixedPropertyOne with public get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyTwo with public get() = 0 and private set (_:int) = ()
+    static member MixedPropertyThree with private get() = 0 and public set (_:int) = ()
+    static member MixedPropertyFour with private get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyFive with internal get() = 0 and public set (_:int) = ()
+    static member MixedPropertySix with internal get() = 0 and private set (_:int) = ()
+    static member MixedPropertySeven with get() = 0 and public set (_:int) = ()
+    static member MixedPropertyEight with get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyNine with get() = 0 and private set (_:int) = ()
+    static member MixedPropertyTen with public get() = 0 and set (_:int) = ()
+    static member MixedPropertyEleven with internal get() = 0 and set (_:int) = ()
+    static member MixedPropertyTwelve with private get() = 0 and set (_:int) = ()"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname static int32 get_MixedPropertyOne() cil managed"
+                ".method assembly specialname static void set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTwo() cil managed"
+                ".method private specialname static void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method private specialname static int32 get_MixedPropertyThree() cil managed"
+                ".method public specialname static void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method private specialname static int32 get_MixedPropertyFour() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFive() cil managed"
+                ".method public specialname static void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySix() cil managed"
+                ".method private specialname static void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public specialname static int32 get_MixedPropertySeven() cil managed"
+                ".method public specialname static void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public specialname static int32 get_MixedPropertyEight() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public specialname static int32 get_MixedPropertyNine() cil managed"
+                ".method private specialname static void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTen() cil managed"
+                ".method public specialname static void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEleven() cil managed"
+                ".method public specialname static void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method private specialname static int32 get_MixedPropertyTwelve() cil managed"
+                ".method public specialname static void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            else
+                ".method assembly specialname static int32 get_MixedPropertyOne() cil managed"
+                ".method assembly specialname static void set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyTwo() cil managed"
+                ".method assembly specialname static void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyThree() cil managed"
+                ".method assembly specialname static void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFour() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFive() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySix() cil managed"
+                ".method assembly specialname static void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySeven() cil managed"
+                ".method assembly specialname static void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEight() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyNine() cil managed"
+                ".method assembly specialname static void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyTen() cil managed"
+                ".method assembly specialname static void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEleven() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyTwelve() cil managed"
+                ".method assembly specialname static void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            ]
+        |> shouldSucceed
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeVisibilityNamespaceRoot.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeVisibilityNamespaceRoot.fs
new file mode 100644
index 00000000000..c12fe0c6829
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeVisibilityNamespaceRoot.fs
@@ -0,0 +1,890 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace EmittedIL.RealInternalSignature
+
+open Xunit
+open FSharp.Test
+open FSharp.Test.Compiler
+
+module ClassTypeVisibilityNamespaceRoot =
+
+    let withRealInternalSignature realSig compilation =
+        compilation
+        |> withOptions [if realSig then "--realsig+" else "--realsig-" ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - constructors`` (realSig) =
+        FSharp """
+namespace RealInternalSignature
+
+type public TypeOne public () = class end
+type public TypeTwo internal () = class end
+type public TypeThree private () = class end
+type public TypeFour () = class end
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+.class public auto ansi serializable RealInternalSignature.TypeOne
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class public auto ansi serializable RealInternalSignature.TypeTwo
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method assembly specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+
+                """
+.class public auto ansi serializable RealInternalSignature.TypeThree
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method private specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class public auto ansi serializable RealInternalSignature.TypeFour
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+            else
+                """
+.class public auto ansi serializable RealInternalSignature.TypeOne
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class public auto ansi serializable RealInternalSignature.TypeTwo
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method assembly specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+
+                """
+.class public auto ansi serializable RealInternalSignature.TypeThree
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method assembly specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class public auto ansi serializable RealInternalSignature.TypeFour
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - constructors`` (realSig) =
+        FSharp """
+namespace RealInternalSignature
+
+type private TypeOne public () = class end
+type private TypeTwo internal () = class end
+type private TypeThree private () = class end
+type private TypeFour () = class end
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+                """
+.class private auto ansi serializable RealInternalSignature.TypeOne
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class private auto ansi serializable RealInternalSignature.TypeTwo
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class private auto ansi serializable RealInternalSignature.TypeThree
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class private auto ansi serializable RealInternalSignature.TypeFour
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+            ]
+        |> shouldSucceed
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - instance methods`` (realSig) =
+        FSharp """
+namespace RealInternalSignature
+
+type public TestType () =
+    member public _.PublicMethod() = ()
+    member internal _.InternalMethod() = ()
+    member private _.PrivateMethod() = ()
+    member _.DefaultMethod() = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig instance void PublicMethod() cil managed"
+                ".method assembly hidebysig instance void InternalMethod() cil managed"
+                ".method private hidebysig instance void PrivateMethod() cil managed"
+                ".method public hidebysig instance void DefaultMethod() cil managed"
+            else
+                ".method public hidebysig instance void PublicMethod() cil managed"
+                ".method assembly hidebysig instance void InternalMethod() cil managed"
+                ".method assembly hidebysig instance void PrivateMethod() cil managed"
+                ".method public hidebysig instance void DefaultMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - instance methods`` (realSig) =
+        FSharp """
+namespace RealInternalSignature
+
+type private TestType () =
+    member public _.PublicMethod() = ()
+    member internal _.InternalMethod() = ()
+    member private _.PrivateMethod() = ()
+    member _.DefaultMethod() = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig instance void PublicMethod() cil managed"
+                ".method assembly hidebysig instance void InternalMethod() cil managed"
+                ".method private hidebysig instance void PrivateMethod() cil managed"
+                ".method public hidebysig instance void DefaultMethod() cil managed"
+
+            else
+                ".method assembly hidebysig instance void PublicMethod() cil managed"
+                ".method assembly hidebysig instance void InternalMethod() cil managed"
+                ".method assembly hidebysig instance void PrivateMethod() cil managed"
+                ".method assembly hidebysig instance void DefaultMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - instance properties`` (realSig) =
+        FSharp """
+namespace RealInternalSignature
+
+type public TestType () =
+    member val public PublicProperty = 0 with get, set
+    member val internal InternalProperty = 0 with get, set
+    member val private PrivateProperty = 0 with get, set
+    member val DefaultProperty = 0 with get, set
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig specialname instance int32 get_PublicProperty() cil managed"
+                ".method public hidebysig specialname instance void set_PublicProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_InternalProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_InternalProperty(int32 v) cil managed"
+                ".method private hidebysig specialname instance int32 get_PrivateProperty() cil managed"
+                ".method private hidebysig specialname instance void set_PrivateProperty(int32 v) cil managed"
+                ".method public hidebysig specialname instance int32 get_DefaultProperty() cil managed"
+                ".method public hidebysig specialname instance void set_DefaultProperty(int32 v) cil managed"
+
+            else
+                ".method public hidebysig specialname instance int32 get_PublicProperty() cil managed"
+                ".method public hidebysig specialname instance void set_PublicProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_InternalProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_InternalProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_PrivateProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_PrivateProperty(int32 v) cil managed"
+                ".method public hidebysig specialname instance int32 get_DefaultProperty() cil managed"
+                ".method public hidebysig specialname instance void set_DefaultProperty(int32 v) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - instance properties`` (realSig) =
+        FSharp """
+namespace RealInternalSignature
+
+type public TestType () =
+    member val public PublicProperty = 0 with get, set
+    member val internal InternalProperty = 0 with get, set
+    member val private PrivateProperty = 0 with get, set
+    member val DefaultProperty = 0 with get, set
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig specialname instance int32 get_PublicProperty() cil managed"
+                ".method public hidebysig specialname instance void set_PublicProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_InternalProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_InternalProperty(int32 v) cil managed"
+                ".method private hidebysig specialname instance int32 get_PrivateProperty() cil managed"
+                ".method private hidebysig specialname instance void set_PrivateProperty(int32 v) cil managed"
+                ".method public hidebysig specialname instance int32 get_DefaultProperty() cil managed"
+                ".method public hidebysig specialname instance void set_DefaultProperty(int32 v) cil managed"
+
+            else
+                ".method public hidebysig specialname instance int32 get_PublicProperty() cil managed"
+                ".method public hidebysig specialname instance void set_PublicProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_InternalProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_InternalProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_PrivateProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_PrivateProperty(int32 v) cil managed"
+                ".method public hidebysig specialname instance int32 get_DefaultProperty() cil managed"
+                ".method public hidebysig specialname instance void set_DefaultProperty(int32 v) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - instance mixed properties`` (realSig) =
+        FSharp """
+namespace RealInternalSignature
+
+type public TestType () =
+    member _.MixedPropertyOne with public get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyTwo with public get() = 0 and private set (_:int) = ()
+    member _.MixedPropertyThree with private get() = 0 and public set (_:int) = ()
+    member _.MixedPropertyFour with private get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyFive with internal get() = 0 and public set (_:int) = ()
+    member _.MixedPropertySix with internal get() = 0 and private set (_:int) = ()
+    member _.MixedPropertySeven with get() = 0 and public set (_:int) = ()
+    member _.MixedPropertyEight with get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyNine with get() = 0 and private set (_:int) = ()
+    member _.MixedPropertyTen with public get() = 0 and set (_:int) = ()
+    member _.MixedPropertyEleven with internal get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTwelve with private get() = 0 and set (_:int) = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname rtspecialname instance void  .ctor() cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyOne() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyTwo() cil managed"
+                ".method private hidebysig specialname instance void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method private hidebysig specialname instance int32 get_MixedPropertyThree() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method private hidebysig specialname instance int32 get_MixedPropertyFour() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFive() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySix() cil managed"
+                ".method private hidebysig specialname instance void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertySeven() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyEight() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyNine() cil managed"
+                ".method private hidebysig specialname instance void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyTen() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEleven() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method private hidebysig specialname instance int32 get_MixedPropertyTwelve() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            else
+                ".method public specialname rtspecialname instance void  .ctor() cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyOne() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyTwo() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyThree() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFour() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFive() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySix() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertySeven() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyEight() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyNine() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyTen() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEleven() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyTwelve() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - instance mixed properties`` (realSig) =
+        FSharp """
+namespace RealInternalSignature
+
+type private TestType () =
+    member _.MixedPropertyOne with public get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyTwo with public get() = 0 and private set (_:int) = ()
+    member _.MixedPropertyThree with private get() = 0 and public set (_:int) = ()
+    member _.MixedPropertyFour with private get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyFive with internal get() = 0 and public set (_:int) = ()
+    member _.MixedPropertySix with internal get() = 0 and private set (_:int) = ()
+    member _.MixedPropertySeven with get() = 0 and public set (_:int) = ()
+    member _.MixedPropertyEight with get() = 0 and internal set (_:int) = ()
+    member _.MixedPropertyNine with get() = 0 and private set (_:int) = ()
+    member _.MixedPropertyTen with public get() = 0 and set (_:int) = ()
+    member _.MixedPropertyEleven with internal get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTwelve with private get() = 0 and set (_:int) = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig specialname instance int32 get_MixedPropertyOne() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyTwo() cil managed"
+                ".method private hidebysig specialname instance void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method private hidebysig specialname instance int32 get_MixedPropertyThree() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method private hidebysig specialname instance int32 get_MixedPropertyFour() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFive() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySix() cil managed"
+                ".method private hidebysig specialname instance void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertySeven() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyEight() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyNine() cil managed"
+                ".method private hidebysig specialname instance void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyTen() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEleven() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method private hidebysig specialname instance int32 get_MixedPropertyTwelve() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+            else
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyOne() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyTwo() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyThree() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFour() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFive() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySix() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySeven() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEight() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyNine() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyTen() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEleven() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyTwelve() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - static methods`` (realSig) =
+        FSharp """
+namespace RealInternalSignature
+
+type public TestType () =
+    static member public  PublicMethod() = ()
+    static member internal  InternalMethod() = ()
+    static member private  PrivateMethod() = ()
+    static member  DefaultMethod() = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method private static void  PrivateMethod() cil managed"
+                ".method public static void  DefaultMethod() cil managed"
+            else
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method assembly static void  PrivateMethod() cil managed"
+                ".method public static void  DefaultMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - static methods`` (realSig) =
+        FSharp """
+namespace RealInternalSignature
+
+type public TestType () =
+    static member public PublicMethod() = ()
+    static member internal InternalMethod() = ()
+    static member private PrivateMethod() = ()
+    static member DefaultMethod() = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method private static void  PrivateMethod() cil managed"
+                ".method public static void  DefaultMethod() cil managed"
+
+            else
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method assembly static void  PrivateMethod() cil managed"
+                ".method public static void  DefaultMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - static properties`` (realSig) =
+        FSharp """
+namespace RealInternalSignature
+
+type public TestType () =
+    static member val public PublicProperty = 0 with get, set
+    static member val internal InternalProperty = 0 with get, set
+    static member val private PrivateProperty = 0 with get, set
+    static member val DefaultProperty = 0 with get, set"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname static int32 get_PublicProperty() cil managed"
+                ".method public specialname static void set_PublicProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_InternalProperty() cil managed"
+                ".method assembly specialname static void set_InternalProperty(int32 v) cil managed"
+                ".method private specialname static int32 get_PrivateProperty() cil managed"
+                ".method private specialname static void set_PrivateProperty(int32 v) cil managed"
+                ".method public specialname static int32 get_DefaultProperty() cil managed"
+                ".method public specialname static void set_DefaultProperty(int32 v) cil managed"
+
+            else
+                ".method public specialname static int32 get_PublicProperty() cil managed"
+                ".method public specialname static void set_PublicProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_InternalProperty() cil managed"
+                ".method assembly specialname static void set_InternalProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_PrivateProperty() cil managed"
+                ".method assembly specialname static void set_PrivateProperty(int32 v) cil managed"
+                ".method public specialname static int32 get_DefaultProperty() cil managed"
+                ".method public specialname static void set_DefaultProperty(int32 v) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - static properties`` (realSig) =
+        FSharp """
+namespace RealInternalSignature
+
+type private TestType () =
+    static member val public PublicProperty = 0 with get, set
+    static member val internal InternalProperty = 0 with get, set
+    static member val private PrivateProperty = 0 with get, set
+    static member val DefaultProperty = 0 with get, set"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname static int32 get_PublicProperty() cil managed"
+                ".method public specialname static void set_PublicProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_InternalProperty() cil managed"
+                ".method assembly specialname static void set_InternalProperty(int32 v) cil managed"
+                ".method private specialname static int32 get_PrivateProperty() cil managed"
+                ".method private specialname static void set_PrivateProperty(int32 v) cil managed"
+                ".method public specialname static int32 get_DefaultProperty() cil managed"
+                ".method public specialname static void set_DefaultProperty(int32 v) cil managed"
+
+            else
+                ".method assembly specialname static int32 get_PublicProperty() cil managed"
+                ".method assembly specialname static void set_PublicProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_InternalProperty() cil managed"
+                ".method assembly specialname static void set_InternalProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_PrivateProperty() cil managed"
+                ".method assembly specialname static void set_PrivateProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_DefaultProperty() cil managed"
+                ".method assembly specialname static void set_DefaultProperty(int32 v) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - static mixed properties`` (realSig) =
+        FSharp """
+namespace RealInternalSignature
+
+type public TestType () =
+    static member MixedPropertyOne with public get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyTwo with public get() = 0 and private set (_:int) = ()
+    static member MixedPropertyThree with private get() = 0 and public set (_:int) = ()
+    static member MixedPropertyFour with private get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyFive with internal get() = 0 and public set (_:int) = ()
+    static member MixedPropertySix with internal get() = 0 and private set (_:int) = ()
+    static member MixedPropertySeven with get() = 0 and public set (_:int) = ()
+    static member MixedPropertyEight with get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyNine with get() = 0 and private set (_:int) = ()
+    static member MixedPropertyTen with public get() = 0 and set (_:int) = ()
+    static member MixedPropertyEleven with internal get() = 0 and set (_:int) = ()
+    static member MixedPropertyTwelve with private get() = 0 and set (_:int) = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname static int32 get_MixedPropertyOne() cil managed"
+                ".method assembly specialname static void set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTwo() cil managed"
+                ".method private specialname static void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method private specialname static int32 get_MixedPropertyThree() cil managed"
+                ".method public specialname static void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method private specialname static int32 get_MixedPropertyFour() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFive() cil managed"
+                ".method public specialname static void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySix() cil managed"
+                ".method private specialname static void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public specialname static int32 get_MixedPropertySeven() cil managed"
+                ".method public specialname static void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public specialname static int32 get_MixedPropertyEight() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public specialname static int32 get_MixedPropertyNine() cil managed"
+                ".method private specialname static void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTen() cil managed"
+                ".method public specialname static void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEleven() cil managed"
+                ".method public specialname static void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method private specialname static int32 get_MixedPropertyTwelve() cil managed"
+                ".method public specialname static void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            else
+                ".method public specialname static int32 get_MixedPropertyOne() cil managed"
+                ".method assembly specialname static void set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTwo() cil managed"
+                ".method assembly specialname static void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyThree() cil managed"
+                ".method public specialname static void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFour() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFive() cil managed"
+                ".method public specialname static void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySix() cil managed"
+                ".method assembly specialname static void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public specialname static int32 get_MixedPropertySeven() cil managed"
+                ".method public specialname static void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public specialname static int32 get_MixedPropertyEight() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public specialname static int32 get_MixedPropertyNine() cil managed"
+                ".method assembly specialname static void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTen() cil managed"
+                ".method public specialname static void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEleven() cil managed"
+                ".method public specialname static void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyTwelve() cil managed"
+                ".method public specialname static void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - static mixed properties`` (realSig) =
+        FSharp """
+namespace RealInternalSignature
+
+type private TestType () =
+    static member MixedPropertyOne with public get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyTwo with public get() = 0 and private set (_:int) = ()
+    static member MixedPropertyThree with private get() = 0 and public set (_:int) = ()
+    static member MixedPropertyFour with private get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyFive with internal get() = 0 and public set (_:int) = ()
+    static member MixedPropertySix with internal get() = 0 and private set (_:int) = ()
+    static member MixedPropertySeven with get() = 0 and public set (_:int) = ()
+    static member MixedPropertyEight with get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyNine with get() = 0 and private set (_:int) = ()
+    static member MixedPropertyTen with public get() = 0 and set (_:int) = ()
+    static member MixedPropertyEleven with internal get() = 0 and set (_:int) = ()
+    static member MixedPropertyTwelve with private get() = 0 and set (_:int) = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname static int32 get_MixedPropertyOne() cil managed"
+                ".method assembly specialname static void set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTwo() cil managed"
+                ".method private specialname static void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method private specialname static int32 get_MixedPropertyThree() cil managed"
+                ".method public specialname static void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method private specialname static int32 get_MixedPropertyFour() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFive() cil managed"
+                ".method public specialname static void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySix() cil managed"
+                ".method private specialname static void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public specialname static int32 get_MixedPropertySeven() cil managed"
+                ".method public specialname static void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public specialname static int32 get_MixedPropertyEight() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public specialname static int32 get_MixedPropertyNine() cil managed"
+                ".method private specialname static void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTen() cil managed"
+                ".method public specialname static void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEleven() cil managed"
+                ".method public specialname static void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method private specialname static int32 get_MixedPropertyTwelve() cil managed"
+                ".method public specialname static void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            else
+                ".method assembly specialname static int32 get_MixedPropertyOne() cil managed"
+                ".method assembly specialname static void set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyTwo() cil managed"
+                ".method assembly specialname static void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyThree() cil managed"
+                ".method assembly specialname static void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFour() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFive() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySix() cil managed"
+                ".method assembly specialname static void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySeven() cil managed"
+                ".method assembly specialname static void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEight() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyNine() cil managed"
+                ".method assembly specialname static void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyTen() cil managed"
+                ".method assembly specialname static void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEleven() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyTwelve() cil managed"
+                ".method assembly specialname static void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            ]
+        |> shouldSucceed
+ 
\ No newline at end of file
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeVisibilityNamespaceRootWithFsi.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeVisibilityNamespaceRootWithFsi.fs
new file mode 100644
index 00000000000..6f3b58e6f66
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ClassTypeVisibilityNamespaceRootWithFsi.fs
@@ -0,0 +1,1253 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace EmittedIL.RealInternalSignature
+
+open Xunit
+open FSharp.Test.Compiler
+
+module ClassTypeVisibilityNamespaceRootWithFsi =
+
+    let withRealInternalSignature realSig compilation =
+        compilation
+        |> withOptions [if realSig then "--realsig+" else "--realsig-" ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - constructors`` (realSig) =
+        Fsi """
+namespace RealInternalSignature
+
+type public TypeOne = public new: unit -> TypeOne
+type public TypeTwo = internal new: unit -> TypeTwo
+type public TypeThree = private new: unit -> TypeThree
+type public TypeFour = public new: unit -> TypeFour
+"""
+        |> withAdditionalSourceFile (FsSource ("""
+namespace RealInternalSignature
+
+type TypeOne () = class end
+type TypeTwo () = class end
+type TypeThree () = class end
+type TypeFour () = class end
+type HiddenType () = class end
+        """))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                """
+.class public auto ansi serializable RealInternalSignature.TypeOne
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class public auto ansi serializable RealInternalSignature.TypeTwo
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method assembly specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class public auto ansi serializable RealInternalSignature.TypeThree
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method private specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class public auto ansi serializable RealInternalSignature.TypeFour
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+                """
+.class private auto ansi serializable RealInternalSignature.HiddenType
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+            else
+                """
+.class public auto ansi serializable RealInternalSignature.TypeOne
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class public auto ansi serializable RealInternalSignature.TypeTwo
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method assembly specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class public auto ansi serializable RealInternalSignature.TypeThree
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method assembly specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class public auto ansi serializable RealInternalSignature.TypeFour
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class private auto ansi serializable RealInternalSignature.HiddenType
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - constructors`` (realSig) =
+        Fsi """
+namespace RealInternalSignature
+
+type private TypeOne = public new: unit -> TypeOne
+type private TypeTwo = internal new: unit -> TypeTwo
+type private TypeThree = private new: unit -> TypeThree
+type private TypeFour = public new: unit -> TypeFour
+"""
+        |> withAdditionalSourceFile (FsSource ("""
+namespace RealInternalSignature
+
+type TypeOne () = class end
+type TypeTwo () = class end
+type TypeThree () = class end
+type TypeFour () = class end
+type HiddenType () = class end
+        """))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+                """
+.class private auto ansi serializable RealInternalSignature.TypeOne
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class private auto ansi serializable RealInternalSignature.TypeTwo
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class private auto ansi serializable RealInternalSignature.TypeThree
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class private auto ansi serializable RealInternalSignature.TypeFour
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+                """
+.class private auto ansi serializable RealInternalSignature.HiddenType
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+}"""
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - instance methods`` (realSig) =
+        Fsi """
+namespace RealInternalSignature
+    type public TestType =
+        new: unit -> TestType
+        member DefaultMethod: unit -> unit
+        member internal InternalMethod: unit -> unit
+        member private PrivateMethod: unit -> unit
+        member PublicMethod: unit -> unit"""
+        |> withAdditionalSourceFile (FsSource ("""
+namespace RealInternalSignature
+
+type TestType () =
+    member _.PublicMethod() = ()
+    member _.InternalMethod() = ()
+    member _.PrivateMethod() = ()
+    member _.DefaultMethod() = ()
+    member _.HiddenMethod() = ()"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig instance void PublicMethod() cil managed"
+                ".method assembly hidebysig instance void InternalMethod() cil managed"
+                ".method private hidebysig instance void PrivateMethod() cil managed"
+                ".method public hidebysig instance void DefaultMethod() cil managed"
+                ".method assembly hidebysig instance void HiddenMethod() cil managed"
+
+            else
+                ".method public hidebysig instance void PublicMethod() cil managed"
+                ".method assembly hidebysig instance void InternalMethod() cil managed"
+                ".method assembly hidebysig instance void PrivateMethod() cil managed"
+                ".method public hidebysig instance void DefaultMethod() cil managed"
+                ".method assembly hidebysig instance void HiddenMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - instance methods`` (realSig) =
+        Fsi """
+namespace RealInternalSignature
+    type private TestType =
+        new: unit -> TestType
+        member DefaultMethod: unit -> unit
+        member internal InternalMethod: unit -> unit
+        member private PrivateMethod: unit -> unit
+        member PublicMethod: unit -> unit"""
+        |> withAdditionalSourceFile (FsSource ("""
+namespace RealInternalSignature
+
+type TestType () =
+    member _.PublicMethod() = ()
+    member _.InternalMethod() = ()
+    member _.PrivateMethod() = ()
+    member _.DefaultMethod() = ()
+    member _.HiddenMethod() = ()"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig instance void PublicMethod() cil managed"
+                ".method assembly hidebysig instance void InternalMethod() cil managed"
+                ".method private hidebysig instance void PrivateMethod() cil managed"
+                ".method public hidebysig instance void DefaultMethod() cil managed"
+                ".method assembly hidebysig instance void HiddenMethod() cil managed"
+
+            else
+                ".method assembly hidebysig instance void PublicMethod() cil managed"
+                ".method assembly hidebysig instance void InternalMethod() cil managed"
+                ".method assembly hidebysig instance void PrivateMethod() cil managed"
+                ".method assembly hidebysig instance void DefaultMethod() cil managed"
+                ".method assembly hidebysig instance void HiddenMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - instance properties`` (realSig) =
+        Fsi """
+namespace RealInternalSignature
+type public TestType =
+    new: unit -> TestType
+    member public PublicProperty: int with get
+    member public PublicProperty: int with set
+    member internal InternalProperty: int with get
+    member internal InternalProperty: int with set
+    member private PrivateProperty: int with get
+    member private PrivateProperty: int with set
+    member DefaultProperty: int with get
+    member DefaultProperty: int with set"""
+        |> withAdditionalSourceFile (FsSource ("""
+namespace RealInternalSignature
+
+type TestType () =
+    member val PublicProperty = 0 with get, set
+    member val InternalProperty = 0 with get, set
+    member val PrivateProperty = 0 with get, set
+    member val DefaultProperty = 0 with get, set
+    member val HiddenProperty = 0 with get, set"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig specialname instance int32 get_PublicProperty() cil managed"
+                ".method public hidebysig specialname instance void set_PublicProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_InternalProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_InternalProperty(int32 v) cil managed"
+                ".method private hidebysig specialname instance int32 get_PrivateProperty() cil managed"
+                ".method private hidebysig specialname instance void set_PrivateProperty(int32 v) cil managed"
+                ".method public hidebysig specialname instance int32 get_DefaultProperty() cil managed"
+                ".method public hidebysig specialname instance void set_DefaultProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_HiddenProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_HiddenProperty(int32 v) cil managed"
+
+            else
+                ".method public hidebysig specialname instance int32 get_PublicProperty() cil managed"
+                ".method public hidebysig specialname instance void set_PublicProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_InternalProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_InternalProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_PrivateProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_PrivateProperty(int32 v) cil managed"
+                ".method public hidebysig specialname instance int32 get_DefaultProperty() cil managed"
+                ".method public hidebysig specialname instance void set_DefaultProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_HiddenProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_HiddenProperty(int32 v) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - instance properties`` (realSig) =
+        Fsi """
+namespace RealInternalSignature
+type private TestType =
+    new: unit -> TestType
+    member public PublicProperty: int with get
+    member public PublicProperty: int with set
+    member internal InternalProperty: int with get
+    member internal InternalProperty: int with set
+    member private PrivateProperty: int with get
+    member private PrivateProperty: int with set
+    member DefaultProperty: int with get
+    member DefaultProperty: int with set"""
+        |> withAdditionalSourceFile (FsSource ("""
+namespace RealInternalSignature
+
+type TestType () =
+    member val PublicProperty = 0 with get, set
+    member val InternalProperty = 0 with get, set
+    member val PrivateProperty = 0 with get, set
+    member val DefaultProperty = 0 with get, set
+    member val HiddenProperty = 0 with get, set"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig specialname instance int32 get_PublicProperty() cil managed"
+                ".method public hidebysig specialname instance void set_PublicProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_InternalProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_InternalProperty(int32 v) cil managed"
+                ".method private hidebysig specialname instance int32 get_PrivateProperty() cil managed"
+                ".method private hidebysig specialname instance void set_PrivateProperty(int32 v) cil managed"
+                ".method public hidebysig specialname instance int32 get_DefaultProperty() cil managed"
+                ".method public hidebysig specialname instance void set_DefaultProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_HiddenProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_HiddenProperty(int32 v) cil managed"
+
+            else
+                ".method assembly hidebysig specialname instance int32  get_PublicProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_PublicProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_InternalProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_InternalProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_PrivateProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_PrivateProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_DefaultProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_DefaultProperty(int32 v) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_HiddenProperty() cil managed"
+                ".method assembly hidebysig specialname instance void  set_HiddenProperty(int32 v) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - instance mixed properties`` (realSig) =
+        Fsi """
+namespace RealInternalSignature
+    type TestType =
+        new: unit -> TestType
+        member public MixedPropertyOne: int with get
+        member internal MixedPropertyOne: int with set
+        member public MixedPropertyTwo: int with get
+        member private MixedPropertyTwo: int with set
+        member private MixedPropertyThree: int with get
+        member public MixedPropertyThree: int with set
+        member private MixedPropertyFour: int with get
+        member internal MixedPropertyFour: int with set
+        member internal MixedPropertyFive: int with get
+        member public MixedPropertyFive: int with set
+        member internal MixedPropertySix: int with get
+        member private MixedPropertySix: int with set
+        member public MixedPropertySeven: int with get
+        member public MixedPropertySeven: int with set
+        member public MixedPropertyEight: int with get
+        member internal MixedPropertyEight: int with set
+        member public MixedPropertyNine: int with get
+        member private MixedPropertyNine: int with set
+        member MixedPropertyTen: int with get
+        member MixedPropertyTen: int with set
+        member internal MixedPropertyEleven: int with get
+        member public MixedPropertyEleven: int with set
+        member private MixedPropertyTwelve: int with get
+        member public MixedPropertyTwelve: int with set"""
+        |> withAdditionalSourceFile (FsSource ("""
+namespace RealInternalSignature
+
+type public TestType () =
+    member _.MixedPropertyOne with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTwo with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyThree with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyFour with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyFive with get() = 0 and set (_:int) = ()
+    member _.MixedPropertySix with get() = 0 and set (_:int) = ()
+    member _.MixedPropertySeven with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyEight with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyNine with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTen with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyEleven with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTwelve with get() = 0 and set (_:int) = ()"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname rtspecialname instance void  .ctor() cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyOne() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyTwo() cil managed"
+                ".method private hidebysig specialname instance void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method private hidebysig specialname instance int32 get_MixedPropertyThree() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method private hidebysig specialname instance int32 get_MixedPropertyFour() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFive() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySix() cil managed"
+                ".method private hidebysig specialname instance void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertySeven() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyEight() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyNine() cil managed"
+                ".method private hidebysig specialname instance void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyTen() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEleven() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method private hidebysig specialname instance int32 get_MixedPropertyTwelve() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            else
+                ".method public specialname rtspecialname instance void  .ctor() cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyOne() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyTwo() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyThree() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFour() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFive() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySix() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertySeven() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyEight() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyNine() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyTen() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEleven() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyTwelve() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - instance mixed properties`` (realSig) =
+        Fsi """
+namespace RealInternalSignature
+    type private TestType =
+        new: unit -> TestType
+        member public MixedPropertyOne: int with get
+        member internal MixedPropertyOne: int with set
+        member public MixedPropertyTwo: int with get
+        member private MixedPropertyTwo: int with set
+        member private MixedPropertyThree: int with get
+        member public MixedPropertyThree: int with set
+        member private MixedPropertyFour: int with get
+        member internal MixedPropertyFour: int with set
+        member internal MixedPropertyFive: int with get
+        member public MixedPropertyFive: int with set
+        member internal MixedPropertySix: int with get
+        member private MixedPropertySix: int with set
+        member public MixedPropertySeven: int with get
+        member public MixedPropertySeven: int with set
+        member public MixedPropertyEight: int with get
+        member internal MixedPropertyEight: int with set
+        member public MixedPropertyNine: int with get
+        member private MixedPropertyNine: int with set
+        member public MixedPropertyTen: int with get
+        member public MixedPropertyTen: int with set
+        member internal MixedPropertyEleven: int with get
+        member public MixedPropertyEleven: int with set
+        member private MixedPropertyTwelve: int with get
+        member public MixedPropertyTwelve: int with set"""
+        |> withAdditionalSourceFile (FsSource ("""
+namespace RealInternalSignature
+
+type public TestType () =
+    member _.MixedPropertyOne with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTwo with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyThree with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyFour with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyFive with get() = 0 and set (_:int) = ()
+    member _.MixedPropertySix with get() = 0 and set (_:int) = ()
+    member _.MixedPropertySeven with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyEight with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyNine with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTen with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyEleven with get() = 0 and set (_:int) = ()
+    member _.MixedPropertyTwelve with get() = 0 and set (_:int) = ()"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public hidebysig specialname instance int32 get_MixedPropertyOne() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyTwo() cil managed"
+                ".method private hidebysig specialname instance void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method private hidebysig specialname instance int32 get_MixedPropertyThree() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method private hidebysig specialname instance int32 get_MixedPropertyFour() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFive() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySix() cil managed"
+                ".method private hidebysig specialname instance void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertySeven() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyEight() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyNine() cil managed"
+                ".method private hidebysig specialname instance void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public hidebysig specialname instance int32 get_MixedPropertyTen() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEleven() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method private hidebysig specialname instance int32 get_MixedPropertyTwelve() cil managed"
+                ".method public hidebysig specialname instance void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+            else
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyOne() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyTwo() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyThree() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFour() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyFive() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySix() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertySeven() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEight() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyNine() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyTen() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyEleven() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method assembly hidebysig specialname instance int32  get_MixedPropertyTwelve() cil managed"
+                ".method assembly hidebysig specialname instance void  set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - static methods`` (realSig) =
+        Fsi """
+namespace RealInternalSignature
+    type public TestType =
+        new: unit -> TestType
+        static member DefaultMethod: unit -> unit
+        static member internal InternalMethod: unit -> unit
+        static member private PrivateMethod: unit -> unit
+        static member PublicMethod: unit -> unit"""
+        |> withAdditionalSourceFile (FsSource ("""
+namespace RealInternalSignature
+
+type TestType () =
+    static member PublicMethod() = ()
+    static member InternalMethod() = ()
+    static member PrivateMethod() = ()
+    static member DefaultMethod() = ()
+    static member HiddenMethod() = ()"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method private static void  PrivateMethod() cil managed"
+                ".method public static void  DefaultMethod() cil managed"
+                ".method assembly static void  HiddenMethod() cil managed"
+
+            else
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method assembly static void  PrivateMethod() cil managed"
+                ".method public static void  DefaultMethod() cil managed"
+                ".method assembly static void  HiddenMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - static methods`` (realSig) =
+        FSharp """
+namespace RealInternalSignature
+
+type public TestType () =
+    static member public PublicMethod() = ()
+    static member internal InternalMethod() = ()
+    static member private PrivateMethod() = ()
+    static member DefaultMethod() = ()
+"""
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method private static void  PrivateMethod() cil managed"
+                ".method public static void  DefaultMethod() cil managed"
+
+            else
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method assembly static void  PrivateMethod() cil managed"
+                ".method public static void  DefaultMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - static properties`` (realSig) =
+        Fsi """
+namespace RealInternalSignature
+type public TestType =
+    new: unit -> TestType
+    static member public PublicProperty: int with get
+    static member public PublicProperty: int with set
+    static member internal InternalProperty: int with get
+    static member internal InternalProperty: int with set
+    static member private PrivateProperty: int with get
+    static member private PrivateProperty: int with set
+    static member DefaultProperty: int with get
+    static member DefaultProperty: int with set"""
+        |> withAdditionalSourceFile (FsSource ("""
+namespace RealInternalSignature
+
+type TestType () =
+    static member val PublicProperty = 0 with get, set
+    static member val InternalProperty = 0 with get, set
+    static member val PrivateProperty = 0 with get, set
+    static member val DefaultProperty = 0 with get, set
+    static member val HiddenProperty = 0 with get, set"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname static int32 get_PublicProperty() cil managed"
+                ".method public specialname static void set_PublicProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_InternalProperty() cil managed"
+                ".method assembly specialname static void set_InternalProperty(int32 v) cil managed"
+                ".method private specialname static int32 get_PrivateProperty() cil managed"
+                ".method private specialname static void set_PrivateProperty(int32 v) cil managed"
+                ".method public specialname static int32 get_DefaultProperty() cil managed"
+                ".method public specialname static void set_DefaultProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_HiddenProperty() cil managed"
+                ".method assembly specialname static void set_HiddenProperty(int32 v) cil managed"
+
+            else
+                ".method public specialname static int32 get_PublicProperty() cil managed"
+                ".method public specialname static void set_PublicProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_InternalProperty() cil managed"
+                ".method assembly specialname static void set_InternalProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_PrivateProperty() cil managed"
+                ".method assembly specialname static void set_PrivateProperty(int32 v) cil managed"
+                ".method public specialname static int32 get_DefaultProperty() cil managed"
+                ".method public specialname static void set_DefaultProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_HiddenProperty() cil managed"
+                ".method assembly specialname static void set_HiddenProperty(int32 v) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - static properties`` (realSig) =
+        Fsi """
+namespace RealInternalSignature
+type private TestType =
+    new: unit -> TestType
+    static member PublicProperty: int with get
+    static member PublicProperty: int with set
+    static member internal InternalProperty: int with get
+    static member internal InternalProperty: int with set
+    static member private PrivateProperty: int with get
+    static member private PrivateProperty: int with set
+    static member DefaultProperty: int with get
+    static member DefaultProperty: int with set"""
+        |> withAdditionalSourceFile (FsSource ("""
+namespace RealInternalSignature
+
+type TestType () =
+    static member val PublicProperty = 0 with get, set
+    static member val InternalProperty = 0 with get, set
+    static member val PrivateProperty = 0 with get, set
+    static member val DefaultProperty = 0 with get, set
+    static member val HiddenProperty = 0 with get, set"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname static int32 get_PublicProperty() cil managed"
+                ".method public specialname static void set_PublicProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_InternalProperty() cil managed"
+                ".method assembly specialname static void set_InternalProperty(int32 v) cil managed"
+                ".method private specialname static int32 get_PrivateProperty() cil managed"
+                ".method private specialname static void set_PrivateProperty(int32 v) cil managed"
+                ".method public specialname static int32 get_DefaultProperty() cil managed"
+                ".method public specialname static void set_DefaultProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_HiddenProperty() cil managed"
+                ".method assembly specialname static void set_HiddenProperty(int32 v) cil managed"
+
+            else
+                ".method assembly specialname static int32 get_PublicProperty() cil managed"
+                ".method assembly specialname static void set_PublicProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_InternalProperty() cil managed"
+                ".method assembly specialname static void set_InternalProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_PrivateProperty() cil managed"
+                ".method assembly specialname static void set_PrivateProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_DefaultProperty() cil managed"
+                ".method assembly specialname static void set_DefaultProperty(int32 v) cil managed"
+                ".method assembly specialname static int32 get_HiddenProperty() cil managed"
+                ".method assembly specialname static void set_HiddenProperty(int32 v) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - static mixed properties`` (realSig) =
+        Fsi """
+namespace RealInternalSignature
+    type public TestType =
+        new: unit -> TestType
+        static member public MixedPropertyOne: int with get
+        static member internal MixedPropertyOne: int with set
+        static member public MixedPropertyTwo: int with get        
+        static member private MixedPropertyTwo: int with set
+        static member private MixedPropertyThree: int with get
+        static member public MixedPropertyThree: int with set
+        static member private MixedPropertyFour: int with get
+        static member internal MixedPropertyFour: int with set
+        static member internal MixedPropertyFive: int with get
+        static member public MixedPropertyFive: int with set
+        static member internal MixedPropertySix: int with get
+        static member private MixedPropertySix: int with set
+        static member public MixedPropertySeven: int with get
+        static member public MixedPropertySeven: int with set
+        static member MixedPropertyEight: int with get
+        static member internal MixedPropertyEight: int with set
+        static member MixedPropertyNine: int with get
+        static member private MixedPropertyNine: int with set
+        static member MixedPropertyTen: int with get
+        static member MixedPropertyTen: int with set
+        static member internal MixedPropertyEleven: int with get
+        static member MixedPropertyEleven: int with set
+        static member private MixedPropertyTwelve: int with get
+        static member MixedPropertyTwelve: int with set
+"""
+        |> withAdditionalSourceFile (FsSource ("""
+namespace RealInternalSignature
+
+type public TestType () =
+    static member MixedPropertyOne with public get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyTwo with public get() = 0 and private set (_:int) = ()
+    static member MixedPropertyThree with private get() = 0 and public set (_:int) = ()
+    static member MixedPropertyFour with private get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyFive with internal get() = 0 and public set (_:int) = ()
+    static member MixedPropertySix with internal get() = 0 and private set (_:int) = ()
+    static member MixedPropertySeven with get() = 0 and public set (_:int) = ()
+    static member MixedPropertyEight with get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyNine with get() = 0 and private set (_:int) = ()
+    static member MixedPropertyTen with public get() = 0 and set (_:int) = ()
+    static member MixedPropertyEleven with internal get() = 0 and set (_:int) = ()
+    static member MixedPropertyTwelve with private get() = 0 and set (_:int) = ()"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname static int32 get_MixedPropertyOne() cil managed"
+                ".method assembly specialname static void set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTwo() cil managed"
+                ".method private specialname static void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method private specialname static int32 get_MixedPropertyThree() cil managed"
+                ".method public specialname static void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method private specialname static int32 get_MixedPropertyFour() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFive() cil managed"
+                ".method public specialname static void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySix() cil managed"
+                ".method private specialname static void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public specialname static int32 get_MixedPropertySeven() cil managed"
+                ".method public specialname static void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public specialname static int32 get_MixedPropertyEight() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public specialname static int32 get_MixedPropertyNine() cil managed"
+                ".method private specialname static void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTen() cil managed"
+                ".method public specialname static void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEleven() cil managed"
+                ".method public specialname static void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method private specialname static int32 get_MixedPropertyTwelve() cil managed"
+                ".method public specialname static void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            else
+                ".method public specialname static int32 get_MixedPropertyOne() cil managed"
+                ".method assembly specialname static void set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTwo() cil managed"
+                ".method assembly specialname static void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyThree() cil managed"
+                ".method public specialname static void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFour() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFive() cil managed"
+                ".method public specialname static void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySix() cil managed"
+                ".method assembly specialname static void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public specialname static int32 get_MixedPropertySeven() cil managed"
+                ".method public specialname static void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public specialname static int32 get_MixedPropertyEight() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public specialname static int32 get_MixedPropertyNine() cil managed"
+                ".method assembly specialname static void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTen() cil managed"
+                ".method public specialname static void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEleven() cil managed"
+                ".method public specialname static void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyTwelve() cil managed"
+                ".method public specialname static void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            ]
+        |> shouldSucceed
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``private type - static mixed properties`` (realSig) =
+        Fsi """
+namespace RealInternalSignature
+type private TestType =
+    new: unit -> TestType
+    static member public MixedPropertyOne: int with get
+    static member internal MixedPropertyOne: int with set
+    static member public MixedPropertyTwo: int with get
+    static member private MixedPropertyTwo: int with set
+    static member private MixedPropertyThree: int with get
+    static member public MixedPropertyThree: int with set
+    static member private MixedPropertyFour: int with get
+    static member internal MixedPropertyFour: int with set
+    static member internal MixedPropertyFive: int with get
+    static member public MixedPropertyFive: int with set
+    static member internal MixedPropertySix: int with get
+    static member private MixedPropertySix: int with set
+    static member MixedPropertySeven: int with get
+    static member MixedPropertySeven: int with set
+    static member public MixedPropertySeven: int with set
+    static member MixedPropertyEight: int with get
+    static member internal MixedPropertyEight: int with set
+    static member MixedPropertyNine: int with get
+    static member private MixedPropertyNine: int with set
+    static member MixedPropertyTen: int with get
+    static member MixedPropertyTen: int with set
+    static member internal MixedPropertyEleven: int with get
+    static member MixedPropertyEleven: int with set
+    static member private MixedPropertyTwelve: int with get
+    static member MixedPropertyTwelve: int with set
+"""
+        |> withAdditionalSourceFile (FsSource ("""
+namespace RealInternalSignature
+
+type private TestType () =
+    static member MixedPropertyOne with public get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyTwo with public get() = 0 and private set (_:int) = ()
+    static member MixedPropertyThree with private get() = 0 and public set (_:int) = ()
+    static member MixedPropertyFour with private get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyFive with internal get() = 0 and public set (_:int) = ()
+    static member MixedPropertySix with internal get() = 0 and private set (_:int) = ()
+    static member MixedPropertySeven with get() = 0 and public set (_:int) = ()
+    static member MixedPropertyEight with get() = 0 and internal set (_:int) = ()
+    static member MixedPropertyNine with get() = 0 and private set (_:int) = ()
+    static member MixedPropertyTen with public get() = 0 and set (_:int) = ()
+    static member MixedPropertyEleven with internal get() = 0 and set (_:int) = ()
+    static member MixedPropertyTwelve with private get() = 0 and set (_:int) = ()"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public specialname static int32 get_MixedPropertyOne() cil managed"
+                ".method assembly specialname static void set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTwo() cil managed"
+                ".method private specialname static void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method private specialname static int32 get_MixedPropertyThree() cil managed"
+                ".method public specialname static void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method private specialname static int32 get_MixedPropertyFour() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFive() cil managed"
+                ".method public specialname static void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySix() cil managed"
+                ".method private specialname static void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method public specialname static int32 get_MixedPropertySeven() cil managed"
+                ".method public specialname static void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method public specialname static int32 get_MixedPropertyEight() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method public specialname static int32 get_MixedPropertyNine() cil managed"
+                ".method private specialname static void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method public specialname static int32 get_MixedPropertyTen() cil managed"
+                ".method public specialname static void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEleven() cil managed"
+                ".method public specialname static void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method private specialname static int32 get_MixedPropertyTwelve() cil managed"
+                ".method public specialname static void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            else
+                ".method assembly specialname static int32 get_MixedPropertyOne() cil managed"
+                ".method assembly specialname static void set_MixedPropertyOne(int32 _arg1) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyTwo() cil managed"
+                ".method assembly specialname static void set_MixedPropertyTwo(int32 _arg2) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyThree() cil managed"
+                ".method assembly specialname static void set_MixedPropertyThree(int32 _arg3) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFour() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFour(int32 _arg4) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyFive() cil managed"
+                ".method assembly specialname static void set_MixedPropertyFive(int32 _arg5) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySix() cil managed"
+                ".method assembly specialname static void set_MixedPropertySix(int32 _arg6) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertySeven() cil managed"
+                ".method assembly specialname static void set_MixedPropertySeven(int32 _arg7) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEight() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEight(int32 _arg8) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyNine() cil managed"
+                ".method assembly specialname static void set_MixedPropertyNine(int32 _arg9) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyTen() cil managed"
+                ".method assembly specialname static void set_MixedPropertyTen(int32 _arg10) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyEleven() cil managed"
+                ".method assembly specialname static void set_MixedPropertyEleven(int32 _arg11) cil managed"
+                ".method assembly specialname static int32 get_MixedPropertyTwelve() cil managed"
+                ".method assembly specialname static void set_MixedPropertyTwelve(int32 _arg12) cil managed"
+
+            ]
+        |> shouldSucceed
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - static methods - hide by omission`` (realSig) =
+        Fsi """
+namespace RealInternalSignature
+    type public TestType =
+        new: unit -> TestType
+        static member PublicMethod: unit -> unit"""
+        |> withAdditionalSourceFile (FsSource ("""
+namespace RealInternalSignature
+
+type TestType () =
+    static member PublicMethod() = ()
+    static member InternalMethod() = ()
+    static member PrivateMethod() = ()
+    static member DefaultMethod() = ()
+    static member HiddenMethod() = ()"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method assembly static void  PrivateMethod() cil managed"
+                ".method assembly static void  DefaultMethod() cil managed"
+                ".method assembly static void  HiddenMethod() cil managed"
+
+            else
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method assembly static void  PrivateMethod() cil managed"
+                ".method assembly static void  DefaultMethod() cil managed"
+                ".method assembly static void  HiddenMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``public type - public nested type - hide by omission`` (realSig) =
+        Fsi """
+namespace RealInternalSignature
+    type public TestType =
+        new: unit -> TestType
+        type public NestedTestType =
+            new: unit -> NestedTestType
+            static member PublicMethod: unit -> unit"""
+        |> withAdditionalSourceFile (FsSource ("""
+namespace RealInternalSignature
+
+type TestType () =
+    static member PublicMethod() = ()
+    type NestedTestType () =
+        static member PublicMethod() = ()
+        static member InternalMethod() = ()
+        static member PrivateMethod() = ()
+        static member DefaultMethod() = ()
+        static member HiddenMethod() = ()"""))
+        |> asLibrary
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compile
+        |> withILContains [
+            if realSig then
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method assembly static void  PrivateMethod() cil managed"
+                ".method assembly static void  DefaultMethod() cil managed"
+                ".method assembly static void  HiddenMethod() cil managed"
+            else
+                ".method public static void  PublicMethod() cil managed"
+                ".method assembly static void  InternalMethod() cil managed"
+                ".method assembly static void  PrivateMethod() cil managed"
+                ".method assembly static void  DefaultMethod() cil managed"
+                ".method assembly static void  HiddenMethod() cil managed"
+
+            ]
+        |> shouldSucceed
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ModuleInitialization.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ModuleInitialization.fs
new file mode 100644
index 00000000000..8666aaad2ac
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ModuleInitialization.fs
@@ -0,0 +1,645 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace EmittedIL.RealInternalSignature
+
+open Xunit
+open FSharp.Test
+open FSharp.Test.Compiler
+
+module ModuleInitialization =
+
+    let withRealInternalSignature realSig compilation =
+        compilation
+        |> withOptions [if realSig then "--realsig+" else "--realsig-" ]
+
+    let simplePublicModule =
+        FSharp """
+namespace MyLibraryNamespace
+module FirstModule =
+    let public   x1 = 1100 + System.Random().Next(0)
+    let internal y1 = 1200 + System.Random().Next(0)
+    let private  z1 = 1300 + System.Random().Next(0)
+    printfn "Hello, World from FirstModule"
+        """
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Simple module in library`` (realSig) =
+
+        let SimplePublicModule =
+            simplePublicModule
+            |> withRealInternalSignature realSig
+            |> asLibrary
+
+        FSharp """
+open MyLibraryNamespace
+printfn $"Hello, World!!!! {FirstModule.x1}"
+        """
+        |> withReferences [ SimplePublicModule ]
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder ["Hello, World from FirstModule"]
+
+    let nestedPublicModule =
+        FSharp """
+namespace MyLibraryNamespace
+module FirstModule =
+    let public   x1 = 1100 + System.Random().Next(0)
+    let internal y1 = 1200 + System.Random().Next(0)
+    let private  z1 = 1300 + System.Random().Next(0)
+    printfn "Hello, World from FirstModule"
+
+    module FirstNestedModule =
+        let public   x11 = 11100 + System.Random().Next(0)
+        let internal y12 = 11200 + System.Random().Next(0)
+        let private  z13 = 11300 + System.Random().Next(0)
+        printfn "Hello, World from FirstModule:FirstNestedModule"
+        """
+
+    let wideNestedPublicModule =
+        FSharp """
+namespace MyLibraryNamespace
+
+    module FirstModule =
+        let x1 = 1101 + System.Random().Next(0)
+        printfn "Hello, World from FirstModule"
+
+        module public FirstNestedModule =
+            let x11 = 1104 + System.Random().Next(0)
+            printfn "Hello, World from FirstModule:FirstNestedModule"
+
+            module private FirstDeepNestedModule =
+                let x111 = 1107 + System.Random().Next(0)
+                printfn "Hello, World from FirstModule:FirstNestedModule:FirstDeepNestedModule"
+
+        module internal SecondNestedModule =
+            let secondNestedDoIt() = ()
+            module private SecondDeepNestedModule =
+                let secondNestedDoIt() = ()
+
+        printfn "Hello, World from between FirstModule:SecondNested and FirstModule:ThirdNestedModule"
+
+        module private ThirdNestedModule =
+            let x13 = 1113 + System.Random().Next(0)
+            printfn "Hello, World from FirstModule:ThirdNestedModule"
+
+            module public ThirdDeepNestedModule =
+                let x132 = 1116 + System.Random().Next(0)
+                printfn "Hello, World from FirstModule:ThirdNestedModule:ThirdDeepNestedModule"
+
+    module SecondModule =
+        let x2 = 2101 + System.Random().Next(0)
+        printfn "Hello, World from SecondModule"
+
+        module public FirstNestedModule =
+            let x21 = 2104 + System.Random().Next(0)
+            printfn "Hello, World from SecondModule:FirstNestedModule"
+
+            module private FirstDeepNestedModule =
+                let x211 = 2107 + System.Random().Next(0)
+                printfn "Hello, World from SecondModule:FirstNestedModule:FirstDeepNestedModule"
+
+        module internal SecondNestedModule =
+            let secondNestedDoIt() = ()
+            module private SecondDeepNestedModule =
+                let secondNestedDoIt() = ()
+
+        printfn "Hello, World from between SecondModule:SecondNested and FirstModule:ThirdNestedModule"
+
+        module private ThirdNestedModule =
+            let x23 = 2113 + System.Random().Next(0)
+
+            module private ThirdDeepNestedModule =
+                let x233 = 2116 + System.Random().Next(0)
+                printfn "Hello, World from SecondModule:ThirdNestedModule:ThirdDeepNestedModule"
+        """
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Wide Nested module in library`` (realSig) =
+
+        let WideNestedPublicModule =
+            wideNestedPublicModule
+            |> withRealInternalSignature realSig
+            |> asLibrary
+
+        FSharp """
+open MyLibraryNamespace
+printfn $"Hello, World!!!! {FirstModule.x1}"
+        """
+        |> withReferences [ WideNestedPublicModule ]
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from FirstModule"
+            "Hello, World from FirstModule:FirstNestedModule"
+            "Hello, World from FirstModule:FirstNestedModule:FirstDeepNestedModule"
+            "Hello, World from between FirstModule:SecondNested and FirstModule:ThirdNestedModule"
+            "Hello, World from FirstModule:ThirdNestedModule"
+            "Hello, World from FirstModule:ThirdNestedModule:ThirdDeepNestedModule"
+            "Hello, World from SecondModule"
+            "Hello, World from SecondModule:FirstNestedModule"
+            "Hello, World from SecondModule:FirstNestedModule:FirstDeepNestedModule"
+            "Hello, World from between SecondModule:SecondNested and FirstModule:ThirdNestedModule"
+            "Hello, World from SecondModule:ThirdNestedModule:ThirdDeepNestedModule"
+            ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Nested module in library`` (realSig) =
+
+        let NestedPublicModule =
+            nestedPublicModule
+            |> withRealInternalSignature realSig
+            |> asLibrary
+
+        FSharp """
+open MyLibraryNamespace
+printfn $"Hello, World!!!! {FirstModule.FirstNestedModule.x11}"
+        """
+        |> withReferences [ NestedPublicModule ]
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from FirstModule"
+            "Hello, World from FirstModule:FirstNestedModule"
+            ]
+
+    let deeplyNestedPublicModule =
+        FSharp """
+namespace MyLibraryNamespace
+
+    module FirstModule =
+        let public   x1 = 1101 + System.Random().Next(0)
+        let internal y1 = 1102 + System.Random().Next(0)
+        let private  z1 = 1103 + System.Random().Next(0)
+        printfn "Hello, World from FirstModule"
+
+        module FirstNestedModule =
+            let x11 = 1104 + System.Random().Next(0)
+            let y11 = 1105 + System.Random().Next(0)
+            let z11 = 1106 + System.Random().Next(0)
+            printfn "Hello, World from FirstModule:FirstNestedModule"
+
+            module FirstDeepNestedModule =
+                let x111 = 1107 + System.Random().Next(0)
+                let y111 = 1108+ System.Random().Next(0)
+                let z111 = 1109 + System.Random().Next(0)
+                printfn "Hello, World from FirstModule:FirstNestedModule:FirstDeepNestedModule"
+
+        module internal SecondNestedModule =
+            module private SecondDeepNestedModule =
+                let x121 = 1110 + System.Random().Next(0)
+                let y121 = 1111 + System.Random().Next(0)
+                let z121 = 1112 + System.Random().Next(0)
+                printfn "Hello, World from FirstModule:SecondNestedModule:SecondDeepNestedModule"
+
+        printfn "Hello, World from between FirstModule:SecondNested and FirstModule:ThirdNestedModule"
+
+        module private ThirdNestedModule =
+            let x13 = 1113 + System.Random().Next(0)
+            let y13 = 1114 + System.Random().Next(0)
+            let z13 = 1115 + System.Random().Next(0)
+            printfn "Hello, World from FirstModule:ThirdNestedModule"
+
+            module private ThirdDeepNestedModule =
+                let x132 = 1116 + System.Random().Next(0)
+                let y132 = 1117 + System.Random().Next(0)
+                let z132 = 1118 + System.Random().Next(0)
+                printfn "Hello, World from FirstModule:ThirdNestedModule:ThirdDeepNestedModule"
+            """
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Deeply Nested module in library - Deep Activation`` (realSig) =
+
+        let DeeplyNestedPublicModule =
+            deeplyNestedPublicModule
+            |> withRealInternalSignature realSig
+            |> asLibrary
+
+        FSharp """
+open MyLibraryNamespace
+printfn $"Hello, World!!!! {FirstModule.FirstNestedModule.FirstDeepNestedModule.x111}"
+        """
+        |> withReferences [ DeeplyNestedPublicModule ]
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from FirstModule"
+            "Hello, World from FirstModule:FirstNestedModule"
+            "Hello, World from FirstModule:FirstNestedModule:FirstDeepNestedModule"
+            "Hello, World from FirstModule:SecondNestedModule:SecondDeepNestedModule"
+            "Hello, World from between FirstModule:SecondNested and FirstModule:ThirdNestedModule"
+            "Hello, World from FirstModule:ThirdNestedModule"
+            "Hello, World from FirstModule:ThirdNestedModule:ThirdDeepNestedModule"
+            ]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Nested module in library - Nested Activation`` (realSig) =
+
+        let DeeplyNestedPublicModule =
+            deeplyNestedPublicModule
+            |> withRealInternalSignature realSig
+            |> asLibrary
+
+        FSharp """
+open MyLibraryNamespace
+printfn $"Hello, World!!!! {FirstModule.FirstNestedModule.x11}"
+        """
+        |> withReferences [ DeeplyNestedPublicModule ]
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from FirstModule"
+            "Hello, World from FirstModule:FirstNestedModule"
+            "Hello, World from FirstModule:FirstNestedModule:FirstDeepNestedModule"
+            "Hello, World from FirstModule:SecondNestedModule:SecondDeepNestedModule"
+            "Hello, World from between FirstModule:SecondNested and FirstModule:ThirdNestedModule"
+            "Hello, World from FirstModule:ThirdNestedModule"
+            "Hello, World from FirstModule:ThirdNestedModule:ThirdDeepNestedModule"
+            ]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Deeply Nested module in library - Shallow Activation`` (realSig) =
+
+        let DeeplyNestedPublicModule =
+            deeplyNestedPublicModule
+            |> withRealInternalSignature realSig
+            |> asLibrary
+
+        FSharp """
+open MyLibraryNamespace
+printfn $"Hello, World!!!! {FirstModule.x1}"
+        """
+        |> withReferences [ DeeplyNestedPublicModule ]
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from FirstModule"
+            "Hello, World from FirstModule:FirstNestedModule"
+            "Hello, World from FirstModule:FirstNestedModule:FirstDeepNestedModule"
+            "Hello, World from FirstModule:SecondNestedModule:SecondDeepNestedModule"
+            "Hello, World from between FirstModule:SecondNested and FirstModule:ThirdNestedModule"
+            "Hello, World from FirstModule:ThirdNestedModule"
+            "Hello, World from FirstModule:ThirdNestedModule:ThirdDeepNestedModule"
+            ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Simple MyLibrary`` (realSig) =
+
+        FSharp """
+module MyLibrary
+let x1 = 1100 + System.Random().Next(0)
+let y1 = 1200 + System.Random().Next(0)
+let z1 = 1300 + System.Random().Next(0)
+printfn "Hello, World from MyLibrary"
+        """
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder ["Hello, World from MyLibrary"]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Simple MyLibrary with nested types`` (realSig) =
+
+        FSharp """
+module MyLibrary
+let x1 = 1100 + System.Random().Next(0)
+let y1 = 1200 + System.Random().Next(0)
+let z1 = 1300 + System.Random().Next(0)
+printfn "Hello, World from MyLibrary"
+
+type MyType =
+    static let x1 = 1100 + System.Random().Next(0)
+    static let _ = printfn "Hello, World from MyLibrary.MyType"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from MyLibrary"
+            "Hello, World from MyLibrary.MyType"
+        ]
+
+    [<InlineData(true, true)>]        // RealSig, recursive module
+    [<InlineData(false, true)>]       // Regular, recursive module
+    [<InlineData(true, false)>]       // RealSig, module
+    [<InlineData(false, false)>]      // Regular, module
+    [<Theory>]
+    let ``Simple MyLibrary with nested types and ref fields`` (realSig) recursiveModule =
+        let recursive = if recursiveModule then "rec" else ""
+        FSharp $"""
+            namespace {recursive} testns
+                module StaticInitializerTest3 =
+                    let x = ref 2
+                    do x := 3
+
+                    type C() = 
+                        static let mutable v = x.Value + 1
+                        static do v <- 3
+
+                        member x.P = v
+                        static member P2 = v+x.Value
+
+                    printfn $"{{(new C()).P}}"
+                    printfn $"{{C.P2}}"
+                    if C.P2 <> 6 then failwith $"Invalid result:  C.P2 <> 6 - actual: {{C.P2}}"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> withOptions [ "--nowarn:3370"; "--debug+"; "--optimize-" ]
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [ "3"; "6" ]
+
+    [<InlineData(true, true)>]        // RealSig, recursive module
+    [<InlineData(false, true)>]       // Regular, recursive module
+    [<InlineData(true, false)>]       // RealSig, module
+    [<InlineData(false, false)>]      // Regular, module
+    [<Theory>]
+    let ``Simple TypeOne and TypeTwo and TypeThree in module`` (realSig, recursiveModule) =
+
+        let recursive = if recursiveModule then "rec" else ""
+        FSharp $"""
+module {recursive} MyModule =
+
+    type public MyFirstType =
+        static let x1 = 1100 + System.Random().Next(0)
+        static let _ = printfn "Hello, World from MyModule.MyFirstType"
+
+    and internal MySecondType =
+        static let x2 = 2100 + System.Random().Next(0)
+        static let _ = printfn "Hello, World from MyModule.MySecondType"
+
+    and private MyThirdType =
+        static let x3 = 3100 + System.Random().Next(0)
+        static let _ = printfn "Hello, World from MyModule.MyThirdType"
+
+    printfn "Hello from main method"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from MyModule.MyFirstType"
+            "Hello, World from MyModule.MySecondType"
+            "Hello, World from MyModule.MyThirdType"
+            "Hello from main method"
+        ]
+
+    [<InlineData(true, true)>]        // RealSig, recursive module
+    [<InlineData(false, true)>]       // Regular, recursive module
+    [<InlineData(true, false)>]       // RealSig, module
+    [<InlineData(false, false)>]      // Regular, module
+    [<Theory>]
+    let ``Simple TypeOne and TypeTwo in nested module`` (realSig, recursiveModule) =
+
+        let recursive = if recursiveModule then "rec" else ""
+        FSharp $$"""
+module {{recursive}} MyModule =
+
+    do  printfn $"Do start MyModule"
+
+    module private MyNestedModule =
+
+        do  printfn $"Do start MyNestedModule"
+
+        type internal MyFirstType =
+            static let _ =  printfn "Hello, World from MyModule.MyNestedModule.MyFirstType"
+            static let _ =  printfn $"{MyFirstType.FirstDoSomething}"
+            static member FirstDoSomething = "My goodness I'm 'MyFirstType'"
+
+        do  printfn $"between types in MyNestedModule"
+
+        type private MySecondType =
+            static let x11 = 1100 + System.Random().Next(0)
+            static let _ =  printfn "Hello, World from MyModule.MyNestedModule.MySecondType"
+            static let _ =  printfn $"{MySecondType.SecondDoSomething}"
+            static member SecondDoSomething = "My goodness I'm 'MySecondType'"
+
+        do  printfn $"Do end MyNestedModule"
+
+    do  printfn $"Do end MyModule"
+
+    [<EntryPoint>]
+    let main args =
+        printfn "Hello from main method"
+        0
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Do start MyModule"
+            "Do start MyNestedModule"
+            "Hello, World from MyModule.MyNestedModule.MyFirstType"
+            "My goodness I'm 'MyFirstType'"
+            "between types in MyNestedModule"
+            "Hello, World from MyModule.MyNestedModule.MySecondType"
+            "My goodness I'm 'MySecondType'"
+            "Do end MyNestedModule"
+            "Do end MyModule"
+        ]
+
+    let withFlavor release compilation =
+        if not release then
+            compilation |> withDebug
+        else
+            compilation
+
+    [<InlineData(true, true)>]          // RealSig, release
+    [<InlineData(false, true)>]         // Regular, release
+    [<InlineData(true, false)>]         // RealSig, debug
+    [<InlineData(false, false)>]        // Regular, debug
+    [<Theory>]
+    let ``recursive types in module`` (realSig, release) =
+        FSharp $$"""
+module rec MyModule =
+    type Node = { Next: Node; Value: int }
+
+    let one = { Next = two; Value = 1 }
+
+    // An intervening type declaration
+    type M() = static member X() = one
+
+    let two = { Next = one; Value = 2 }
+
+    let test t s1 s2 =
+      if s1 <> s2 then
+        stdout.WriteLine ($"test:{t} '{s1}' '{s2}' failed")
+      else
+        stdout.WriteLine ($"test:{t} '{s1}' '{s2}' succeeded")
+
+    [<EntryPoint>]
+    let main args =
+        test "one.Value 1" one.Value 1
+        test "one.Next.Value 2" one.Next.Value 2
+        test "(M.X()).Value 1" (M.X()).Value 1
+        test "(M.X()).Next.Value 2" (M.X()).Next.Value 2
+        test "(M.X()).Next.Next.Value 1" (M.X()).Next.Next.Value 1
+        test "two.Value 2" two.Value 2
+        test "two.Next.Value 1" two.Next.Value 1
+        test "two.Next.Next.Value 2" two.Next.Next.Value 2
+        0
+            """
+        |> withFlavor release
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "test:one.Value 1 '1' '1' succeeded"
+            "test:one.Next.Value 2 '2' '2' succeeded"
+            "test:(M.X()).Value 1 '1' '1' succeeded"
+            "test:(M.X()).Next.Value 2 '2' '2' succeeded"
+            "test:(M.X()).Next.Next.Value 1 '1' '1' succeeded"
+            "test:two.Value 2 '2' '2' succeeded"
+            "test:two.Next.Value 1 '1' '1' succeeded"
+            "test:two.Next.Next.Value 2 '2' '2' succeeded"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Module Nested Type visibility`` (realSig) =
+
+        FSharp """
+module internal PrintfImpl
+
+    module private FormatString =
+        let x = 0
+        let findNextFormatSpecifier () = $"FormatString.findNextFormatSpecifier () - {x}"
+
+    type FormatParser () =
+        let parseAndCreateStepsForCapturedFormat () =
+            $"FormatParser.prefix : " + FormatString.findNextFormatSpecifier()
+        member _.GetStepsForCapturedFormat() =
+            parseAndCreateStepsForCapturedFormat ()
+
+    printfn $"FormatParser.prefix: {FormatParser().GetStepsForCapturedFormat()}"
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "FormatParser.prefix: FormatParser.prefix : FormatString.findNextFormatSpecifier ()"
+            "Main program"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Class Type visibility in module - public type - private ctor`` (realSig) =
+
+        FSharp """
+module FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type public FSharpSourceFromFile internal (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+let createFromFile filePath = FSharpSourceFromFile (filePath) :> FSharpSource
+
+module doit =
+    createFromFile("Hello") |> ignore
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Lazy nested module - private`` (realSig) =
+
+        FSharp """
+module private TestReferences =
+
+    [<RequireQualifiedAccess>]
+    module NetStandard20 =
+        module Files =
+            let netStandard = lazy "Hello, World!!!"
+
+module doSomething =
+    printfn $"{TestReferences.NetStandard20.Files.netStandard.Value}"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``module visibility - Datum`` (realSig) =
+
+        FSharp """
+module Test6
+    module internal HelperModule = 
+            
+        type public Data = 
+            private
+                {
+                    Datum: int
+                }
+                    
+        let internal handle (data:Data): int = data.Datum
+            
+    module public Module =
+            
+        type public Data = 
+            private
+                {
+                    Thing: HelperModule.Data
+                }
+
+        let public getInt (data:Data): int = HelperModule.handle data.Thing               
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> asLibrary
+        |> compile
+        |> shouldSucceed
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ModuleVisibility.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ModuleVisibility.fs
new file mode 100644
index 00000000000..f382ec2c971
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/ModuleVisibility.fs
@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace EmittedIL.RealInternalSignature
+
+open Xunit
+open FSharp.Test
+open FSharp.Test.Compiler
+
+module ModuleVisibility =
+    ()
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/RealInternalSignature.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/RealInternalSignature.fs
new file mode 100644
index 00000000000..b0b12e502d0
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/RealInternalSignature/RealInternalSignature.fs
@@ -0,0 +1,1255 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace EmittedIL
+
+open Xunit
+open FSharp.Test
+open FSharp.Test.Compiler
+
+module RealInternalSignature =
+
+    let withRealInternalSignature realSig compilation =
+        compilation
+        |> withOptions [if realSig then "--realsig+" else "--realsig-" ]
+
+    let simplePublicModule =
+        FSharp """
+namespace MyLibraryNamespace
+module FirstModule =
+    let public   x1 = 1100 + System.Random().Next(0)
+    let internal y1 = 1200 + System.Random().Next(0)
+    let private  z1 = 1300 + System.Random().Next(0)
+    printfn "Hello, World from FirstModule"
+        """
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Simple module in library`` (realSig) =
+
+        let SimplePublicModule =
+            simplePublicModule
+            |> withRealInternalSignature realSig
+            |> asLibrary
+
+        FSharp """
+open MyLibraryNamespace
+printfn $"Hello, World!!!! {FirstModule.x1}"
+        """
+        |> withReferences [ SimplePublicModule ]
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder ["Hello, World from FirstModule"]
+
+    let nestedPublicModule =
+        FSharp """
+namespace MyLibraryNamespace
+module FirstModule =
+    let public   x1 = 1100 + System.Random().Next(0)
+    let internal y1 = 1200 + System.Random().Next(0)
+    let private  z1 = 1300 + System.Random().Next(0)
+    printfn "Hello, World from FirstModule"
+
+    module FirstNestedModule =
+        let public   x11 = 11100 + System.Random().Next(0)
+        let internal y12 = 11200 + System.Random().Next(0)
+        let private  z13 = 11300 + System.Random().Next(0)
+        printfn "Hello, World from FirstModule:FirstNestedModule"
+        """
+
+    let wideNestedPublicModule =
+        FSharp """
+namespace MyLibraryNamespace
+
+    module FirstModule =
+        let x1 = 1101 + System.Random().Next(0)
+        printfn "Hello, World from FirstModule"
+
+        module public FirstNestedModule =
+            let x11 = 1104 + System.Random().Next(0)
+            printfn "Hello, World from FirstModule:FirstNestedModule"
+
+            module private FirstDeepNestedModule =
+                let x111 = 1107 + System.Random().Next(0)
+                printfn "Hello, World from FirstModule:FirstNestedModule:FirstDeepNestedModule"
+
+        module internal SecondNestedModule =
+            let secondNestedDoIt() = ()
+            module private SecondDeepNestedModule =
+                let secondNestedDoIt() = ()
+
+        printfn "Hello, World from between FirstModule:SecondNested and FirstModule:ThirdNestedModule"
+
+        module private ThirdNestedModule =
+            let x13 = 1113 + System.Random().Next(0)
+            printfn "Hello, World from FirstModule:ThirdNestedModule"
+
+            module public ThirdDeepNestedModule =
+                let x132 = 1116 + System.Random().Next(0)
+                printfn "Hello, World from FirstModule:ThirdNestedModule:ThirdDeepNestedModule"
+
+    module SecondModule =
+        let x2 = 2101 + System.Random().Next(0)
+        printfn "Hello, World from SecondModule"
+
+        module public FirstNestedModule =
+            let x21 = 2104 + System.Random().Next(0)
+            printfn "Hello, World from SecondModule:FirstNestedModule"
+
+            module private FirstDeepNestedModule =
+                let x211 = 2107 + System.Random().Next(0)
+                printfn "Hello, World from SecondModule:FirstNestedModule:FirstDeepNestedModule"
+
+        module internal SecondNestedModule =
+            let secondNestedDoIt() = ()
+            module private SecondDeepNestedModule =
+                let secondNestedDoIt() = ()
+
+        printfn "Hello, World from between SecondModule:SecondNested and FirstModule:ThirdNestedModule"
+
+        module private ThirdNestedModule =
+            let x23 = 2113 + System.Random().Next(0)
+
+            module private ThirdDeepNestedModule =
+                let x233 = 2116 + System.Random().Next(0)
+                printfn "Hello, World from SecondModule:ThirdNestedModule:ThirdDeepNestedModule"
+        """
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Wide Nested module in library`` (realSig) =
+
+        let WideNestedPublicModule =
+            wideNestedPublicModule
+            |> withRealInternalSignature realSig
+            |> asLibrary
+
+        FSharp """
+open MyLibraryNamespace
+printfn $"Hello, World!!!! {FirstModule.x1}"
+        """
+        |> withReferences [ WideNestedPublicModule ]
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from FirstModule"
+            "Hello, World from FirstModule:FirstNestedModule"
+            "Hello, World from FirstModule:FirstNestedModule:FirstDeepNestedModule"
+            "Hello, World from between FirstModule:SecondNested and FirstModule:ThirdNestedModule"
+            "Hello, World from FirstModule:ThirdNestedModule"
+            "Hello, World from FirstModule:ThirdNestedModule:ThirdDeepNestedModule"
+            "Hello, World from SecondModule"
+            "Hello, World from SecondModule:FirstNestedModule"
+            "Hello, World from SecondModule:FirstNestedModule:FirstDeepNestedModule"
+            "Hello, World from between SecondModule:SecondNested and FirstModule:ThirdNestedModule"
+            "Hello, World from SecondModule:ThirdNestedModule:ThirdDeepNestedModule"
+            ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Nested module in library`` (realSig) =
+
+        let NestedPublicModule =
+            nestedPublicModule
+            |> withRealInternalSignature realSig
+            |> asLibrary
+
+        FSharp """
+open MyLibraryNamespace
+printfn $"Hello, World!!!! {FirstModule.FirstNestedModule.x11}"
+        """
+        |> withReferences [ NestedPublicModule ]
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from FirstModule"
+            "Hello, World from FirstModule:FirstNestedModule"
+            ]
+
+    let deeplyNestedPublicModule =
+        FSharp """
+namespace MyLibraryNamespace
+
+    module FirstModule =
+        let public   x1 = 1101 + System.Random().Next(0)
+        let internal y1 = 1102 + System.Random().Next(0)
+        let private  z1 = 1103 + System.Random().Next(0)
+        printfn "Hello, World from FirstModule"
+
+        module FirstNestedModule =
+            let x11 = 1104 + System.Random().Next(0)
+            let y11 = 1105 + System.Random().Next(0)
+            let z11 = 1106 + System.Random().Next(0)
+            printfn "Hello, World from FirstModule:FirstNestedModule"
+
+            module FirstDeepNestedModule =
+                let x111 = 1107 + System.Random().Next(0)
+                let y111 = 1108+ System.Random().Next(0)
+                let z111 = 1109 + System.Random().Next(0)
+                printfn "Hello, World from FirstModule:FirstNestedModule:FirstDeepNestedModule"
+
+        module internal SecondNestedModule =
+            module private SecondDeepNestedModule =
+                let x121 = 1110 + System.Random().Next(0)
+                let y121 = 1111 + System.Random().Next(0)
+                let z121 = 1112 + System.Random().Next(0)
+                printfn "Hello, World from FirstModule:SecondNestedModule:SecondDeepNestedModule"
+
+        printfn "Hello, World from between FirstModule:SecondNested and FirstModule:ThirdNestedModule"
+
+        module private ThirdNestedModule =
+            let x13 = 1113 + System.Random().Next(0)
+            let y13 = 1114 + System.Random().Next(0)
+            let z13 = 1115 + System.Random().Next(0)
+            printfn "Hello, World from FirstModule:ThirdNestedModule"
+
+            module private ThirdDeepNestedModule =
+                let x132 = 1116 + System.Random().Next(0)
+                let y132 = 1117 + System.Random().Next(0)
+                let z132 = 1118 + System.Random().Next(0)
+                printfn "Hello, World from FirstModule:ThirdNestedModule:ThirdDeepNestedModule"
+            """
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Deeply Nested module in library - Deep Activation`` (realSig) =
+
+        let DeeplyNestedPublicModule =
+            deeplyNestedPublicModule
+            |> withRealInternalSignature realSig
+            |> asLibrary
+
+        FSharp """
+open MyLibraryNamespace
+printfn $"Hello, World!!!! {FirstModule.FirstNestedModule.FirstDeepNestedModule.x111}"
+        """
+        |> withReferences [ DeeplyNestedPublicModule ]
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from FirstModule"
+            "Hello, World from FirstModule:FirstNestedModule"
+            "Hello, World from FirstModule:FirstNestedModule:FirstDeepNestedModule"
+            "Hello, World from FirstModule:SecondNestedModule:SecondDeepNestedModule"
+            "Hello, World from between FirstModule:SecondNested and FirstModule:ThirdNestedModule"
+            "Hello, World from FirstModule:ThirdNestedModule"
+            "Hello, World from FirstModule:ThirdNestedModule:ThirdDeepNestedModule"
+            ]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Nested module in library - Nested Activation`` (realSig) =
+
+        let DeeplyNestedPublicModule =
+            deeplyNestedPublicModule
+            |> withRealInternalSignature realSig
+            |> asLibrary
+
+        FSharp """
+open MyLibraryNamespace
+printfn $"Hello, World!!!! {FirstModule.FirstNestedModule.x11}"
+        """
+        |> withReferences [ DeeplyNestedPublicModule ]
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from FirstModule"
+            "Hello, World from FirstModule:FirstNestedModule"
+            "Hello, World from FirstModule:FirstNestedModule:FirstDeepNestedModule"
+            "Hello, World from FirstModule:SecondNestedModule:SecondDeepNestedModule"
+            "Hello, World from between FirstModule:SecondNested and FirstModule:ThirdNestedModule"
+            "Hello, World from FirstModule:ThirdNestedModule"
+            "Hello, World from FirstModule:ThirdNestedModule:ThirdDeepNestedModule"
+            ]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Deeply Nested module in library - Shallow Activation`` (realSig) =
+
+        let DeeplyNestedPublicModule =
+            deeplyNestedPublicModule
+            |> withRealInternalSignature realSig
+            |> asLibrary
+
+        FSharp """
+open MyLibraryNamespace
+printfn $"Hello, World!!!! {FirstModule.x1}"
+        """
+        |> withReferences [ DeeplyNestedPublicModule ]
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from FirstModule"
+            "Hello, World from FirstModule:FirstNestedModule"
+            "Hello, World from FirstModule:FirstNestedModule:FirstDeepNestedModule"
+            "Hello, World from FirstModule:SecondNestedModule:SecondDeepNestedModule"
+            "Hello, World from between FirstModule:SecondNested and FirstModule:ThirdNestedModule"
+            "Hello, World from FirstModule:ThirdNestedModule"
+            "Hello, World from FirstModule:ThirdNestedModule:ThirdDeepNestedModule"
+            ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Simple MyLibrary`` (realSig) =
+
+        FSharp """
+module MyLibrary
+let x1 = 1100 + System.Random().Next(0)
+let y1 = 1200 + System.Random().Next(0)
+let z1 = 1300 + System.Random().Next(0)
+printfn "Hello, World from MyLibrary"
+        """
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder ["Hello, World from MyLibrary"]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Simple MyLibrary with nested types`` (realSig) =
+
+        FSharp """
+module MyLibrary
+let x1 = 1100 + System.Random().Next(0)
+let y1 = 1200 + System.Random().Next(0)
+let z1 = 1300 + System.Random().Next(0)
+printfn "Hello, World from MyLibrary"
+
+type MyType =
+    static let x1 = 1100 + System.Random().Next(0)
+    static let _ = printfn "Hello, World from MyLibrary.MyType"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from MyLibrary"
+            "Hello, World from MyLibrary.MyType"
+        ]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Simple MyType in namespace`` (realSig) =
+
+        FSharp """
+namespace MyLibrary
+type MyFirstType =
+    static let x1 = 1100 + System.Random().Next(0)
+    static let _ = printfn "Hello, World from MyLibrary.MyFirstType"
+
+type MySecondType =
+    static let x2 = 2100 + System.Random().Next(0)
+    static let _ = printfn "Hello, World from MyLibrary.MySecondType"
+
+module MyModule =
+    [<EntryPoint>]
+    let main args =
+        printfn "Hello from main method"
+        0
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from MyLibrary.MyFirstType"
+            "Hello, World from MyLibrary.MySecondType"
+            "Hello from main method"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Simple TypeOne and TypeTwo in namespace`` (realSig) =
+
+        FSharp """
+namespace MyLibrary
+type MyFirstType =
+    static let x1 = 1100 + System.Random().Next(0)
+    static let _ = printfn "Hello, World from MyLibrary.MyFirstType"
+
+and MySecondType =
+    static let x2 = 2100 + System.Random().Next(0)
+    static let _ = printfn "Hello, World from MyLibrary.MySecondType"
+
+module MyModule =
+    [<EntryPoint>]
+    let main args =
+        printfn "Hello from main method"
+        0
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from MyLibrary.MyFirstType"
+            "Hello, World from MyLibrary.MySecondType"
+            "Hello from main method"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Simple TypeOne and TypeTwo in module`` (realSig) =
+
+        FSharp """
+module MyModule =
+
+    type public MyFirstType =
+        static let x1 = 1100 + System.Random().Next(0)
+        static let _ = printfn "Hello, World from MyModule.MyFirstType"
+
+    and internal MySecondType =
+        static let x2 = 2100 + System.Random().Next(0)
+        static let _ = printfn "Hello, World from MyModule.MySecondType"
+
+    and private MyThirdType =
+        static let x3 = 3100 + System.Random().Next(0)
+        static let _ = printfn "Hello, World from MyModule.MyThirdType"
+
+    printfn "Hello from main method"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from MyModule.MyFirstType"
+            "Hello, World from MyModule.MySecondType"
+            "Hello, World from MyModule.MyThirdType"
+            "Hello from main method"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Simple TypeOne and TypeTwo in nested module`` (realSig) =
+
+        FSharp """
+module MyModule =
+
+    module private MyNestedModule =
+        type internal MyFirstType =
+            static let x1 = 1100 + System.Random().Next(0)
+            static let _ =  printfn "Hello, World from MyModule.MyNestedModule.MyFirstType"
+            static let _ =  printfn $"{MyFirstType.DoSomething}"
+            static member DoSomething = "My goodness"
+
+        and private MySecondType =
+            static let x11 = 1100 + System.Random().Next(0)
+            static let _ =  printfn "Hello, World from MyModule.MyNestedModule.MySecondType"
+
+    [<EntryPoint>]
+    let main args =
+        printfn "Hello from main method"
+        0
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World from MyModule.MyNestedModule.MyFirstType"
+            "My goodness"
+            "Hello, World from MyModule.MyNestedModule.MySecondType"
+            "Hello from main method"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Module Nested Type visibility`` (realSig) =
+
+        FSharp """
+module internal PrintfImpl
+
+    module private FormatString =
+        let x = 0
+        let findNextFormatSpecifier () = $"FormatString.findNextFormatSpecifier () - {x}"
+
+    type FormatParser () =
+        let parseAndCreateStepsForCapturedFormat () =
+            $"FormatParser.prefix : " + FormatString.findNextFormatSpecifier()
+        member _.GetStepsForCapturedFormat() =
+            parseAndCreateStepsForCapturedFormat ()
+
+    printfn $"FormatParser.prefix: {FormatParser().GetStepsForCapturedFormat()}"
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "FormatParser.prefix: FormatParser.prefix : FormatString.findNextFormatSpecifier ()"
+            "Main program"
+        ]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Class Type visibility - public type - public ctor`` (realSig) =
+
+        FSharp """
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type FSharpSourceFromFile public (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+type FSharpSource with
+
+    static member CreateFromFile (filePath: string) =
+        ()  //FSharpSourceFromFile(filePath) :> FSharpSource
+
+module doit =
+    FSharpSource.CreateFromFile("Hello") |> ignore
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Class Type visibility - public type - internal ctor`` (realSig) =
+
+        FSharp """
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type FSharpSourceFromFile internal (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+type FSharpSource with
+
+    static member CreateFromFile(filePath: string) =
+        FSharpSourceFromFile(filePath) :> FSharpSource
+
+module doit =
+    FSharpSource.CreateFromFile("Hello") |> ignore
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Class Type visibility - public type - private ctor`` (realSig) =
+
+        FSharp """
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type FSharpSourceFromFile private (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+type FSharpSource with
+
+    static member CreateFromFile (filePath: string) =
+        ()  //FSharpSourceFromFile(filePath) :> FSharpSource
+
+module doit =
+    FSharpSource.CreateFromFile("Hello") |> ignore
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Class Type visibility - public type - unspecified ctor`` (realSig) =
+
+        FSharp """
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type FSharpSourceFromFile (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+type FSharpSource with
+
+    static member CreateFromFile (filePath: string) =
+        ()  //FSharpSourceFromFile(filePath) :> FSharpSource
+
+module doit =
+    FSharpSource.CreateFromFile("Hello") |> ignore
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Class Type visibility - private type - public ctor`` (realSig) =
+
+        FSharp """
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type private FSharpSourceFromFile public (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+type FSharpSource with
+
+    static member CreateFromFile (filePath: string) =
+        ()  //FSharpSourceFromFile(filePath) :> FSharpSource
+
+module doit =
+    FSharpSource.CreateFromFile("Hello") |> ignore
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Class Type visibility - private type - internal ctor`` (realSig) =
+
+        FSharp """
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type private FSharpSourceFromFile internal (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+type FSharpSource with
+
+    static member CreateFromFile(filePath: string) =
+        FSharpSourceFromFile(filePath) :> FSharpSource
+
+module doit =
+    FSharpSource.CreateFromFile("Hello") |> ignore
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> verifyIL [
+            if realSig = false then
+                // Initialization
+                """
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Test
+       extends [runtime]System.Object
+{
+  .field static assembly class FSharp.Compiler.CodeAnalysis.FSharpSource arg@1
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ldstr      "Hello"
+    IL_0005:  newobj     instance void FSharp.Compiler.CodeAnalysis.FSharpSourceFromFile::.ctor(string)
+    IL_000a:  stsfld     class FSharp.Compiler.CodeAnalysis.FSharpSource '<StartupCode$assembly>'.$Test::arg@1
+    IL_000f:  ldstr      "Main program"
+    IL_0014:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_0019:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_001e:  pop
+    IL_001f:  ret
+  }"""
+
+                // FSharpSource visibility
+                """.class public abstract auto ansi serializable FSharp.Compiler.CodeAnalysis.FSharpSource
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.AbstractClassAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public hidebysig specialname abstract virtual 
+          instance string  get_FilePath() cil managed
+  {
+  } 
+
+  .method public specialname rtspecialname 
+          instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+  .method public static class FSharp.Compiler.CodeAnalysis.FSharpSource 
+          CreateFromFile(string filePath) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  newobj     instance void FSharp.Compiler.CodeAnalysis.FSharpSourceFromFile::.ctor(string)
+    IL_0006:  ret
+  } 
+
+  .property instance string FilePath()
+  {
+    .get instance string FSharp.Compiler.CodeAnalysis.FSharpSource::get_FilePath()
+  } 
+}"""
+
+                /// FSharpSourceFromFile
+                """.class private auto ansi serializable FSharp.Compiler.CodeAnalysis.FSharpSourceFromFile
+       extends FSharp.Compiler.CodeAnalysis.FSharpSource
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .field assembly string filePath
+  .method public specialname rtspecialname 
+          instance void  .ctor(string filePath) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void FSharp.Compiler.CodeAnalysis.FSharpSource::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  ldarg.1
+    IL_000a:  stfld      string FSharp.Compiler.CodeAnalysis.FSharpSourceFromFile::filePath
+    IL_000f:  ret
+  } 
+
+  .method public hidebysig specialname virtual 
+          instance string  get_FilePath() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      string FSharp.Compiler.CodeAnalysis.FSharpSourceFromFile::filePath
+    IL_0006:  ret
+  } 
+
+  .property instance string FilePath()
+  {
+    .get instance string FSharp.Compiler.CodeAnalysis.FSharpSourceFromFile::get_FilePath()
+  } 
+}"""
+                //doit
+                """.class public abstract auto ansi sealed FSharp.Compiler.CodeAnalysis.doit
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method assembly specialname static class FSharp.Compiler.CodeAnalysis.FSharpSource 
+          get_arg@1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class FSharp.Compiler.CodeAnalysis.FSharpSource '<StartupCode$assembly>'.$Test::arg@1
+    IL_0005:  ret
+  } 
+
+  .property class FSharp.Compiler.CodeAnalysis.FSharpSource
+          arg@1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class FSharp.Compiler.CodeAnalysis.FSharpSource FSharp.Compiler.CodeAnalysis.doit::get_arg@1()
+  } 
+}"""
+        else
+                // Initialization
+                """.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Test
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void FSharp.Compiler.CodeAnalysis.doit::staticInitialization@()
+    IL_0005:  ret
+  }"""
+
+                // FSharpSource visibility
+                """.class public abstract auto ansi serializable FSharp.Compiler.CodeAnalysis.FSharpSource
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.AbstractClassAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .method public hidebysig specialname abstract virtual 
+          instance string  get_FilePath() cil managed
+  {
+  } 
+
+  .method public specialname rtspecialname 
+          instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+  .method public static class FSharp.Compiler.CodeAnalysis.FSharpSource 
+          CreateFromFile(string filePath) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  newobj     instance void FSharp.Compiler.CodeAnalysis.FSharpSourceFromFile::.ctor(string)
+    IL_0006:  ret
+  } 
+
+  .property instance string FilePath()
+  {
+    .get instance string FSharp.Compiler.CodeAnalysis.FSharpSource::get_FilePath()
+  } 
+}"""
+
+                // FSharpSourceFromFile
+                """.class private auto ansi serializable FSharp.Compiler.CodeAnalysis.FSharpSourceFromFile
+       extends FSharp.Compiler.CodeAnalysis.FSharpSource
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .field assembly string filePath
+  .method assembly specialname rtspecialname 
+          instance void  .ctor(string filePath) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void FSharp.Compiler.CodeAnalysis.FSharpSource::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  ldarg.1
+    IL_000a:  stfld      string FSharp.Compiler.CodeAnalysis.FSharpSourceFromFile::filePath
+    IL_000f:  ret
+  } 
+
+  .method public hidebysig specialname virtual 
+          instance string  get_FilePath() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      string FSharp.Compiler.CodeAnalysis.FSharpSourceFromFile::filePath
+    IL_0006:  ret
+  } 
+
+  .property instance string FilePath()
+  {
+    .get instance string FSharp.Compiler.CodeAnalysis.FSharpSourceFromFile::get_FilePath()
+  } 
+}"""
+
+                // doit
+                """.class public abstract auto ansi sealed FSharp.Compiler.CodeAnalysis.doit
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly class FSharp.Compiler.CodeAnalysis.FSharpSource arg@1
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method assembly specialname static class FSharp.Compiler.CodeAnalysis.FSharpSource 
+          get_arg@1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class FSharp.Compiler.CodeAnalysis.FSharpSource FSharp.Compiler.CodeAnalysis.doit::arg@1
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static 
+          void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Test::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Test::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly static void  staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldstr      "Hello"
+    IL_0005:  newobj     instance void FSharp.Compiler.CodeAnalysis.FSharpSourceFromFile::.ctor(string)
+    IL_000a:  stsfld     class FSharp.Compiler.CodeAnalysis.FSharpSource FSharp.Compiler.CodeAnalysis.doit::arg@1
+    IL_000f:  ldstr      "Main program"
+    IL_0014:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_0019:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_001e:  pop
+    IL_001f:  ret
+  } 
+
+  .property class FSharp.Compiler.CodeAnalysis.FSharpSource
+          arg@1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class FSharp.Compiler.CodeAnalysis.FSharpSource FSharp.Compiler.CodeAnalysis.doit::get_arg@1()
+  } 
+}"""
+          ]
+        //|> withStdOutContainsAllInOrder [
+        //    "Main program"
+        //]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Class Type visibility - private type - private ctor`` (realSig) =
+
+        FSharp """
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type public FSharpSourcePublic () =
+    abstract PublicFilePath: string
+
+[<AbstractClass>]
+type internal FSharpSource () =
+    inherit FSharpSourcePublic()
+    abstract InternalFilePath: string
+
+type private FSharpSourceFromFile private (filePath: string) =
+    inherit FSharpSource()
+
+    override _.PublicFilePath = filePath
+    override _.InternalFilePath = filePath
+    member   _.PrivateFilePath = filePath
+
+type FSharpSource with
+
+    static member public PublicCreateFromFile (filePath: string) = ()
+    static member internal InternalCreateFromFile (filePath: string) = ()
+    static member private PrivateCreateFromFile (filePath: string) = ()
+
+module doit =
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Class Type visibility - private type - unspecified ctor`` (realSig) =
+
+        FSharp """
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type private FSharpSourceFromFile (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+type FSharpSource with
+
+    static member CreateFromFile (filePath: string) =
+        FSharpSourceFromFile(filePath) :> FSharpSource
+
+module doit =
+    FSharpSource.CreateFromFile("Hello") |> ignore
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Class Type visibility in module - public type - private ctor`` (realSig) =
+
+        FSharp """
+module FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type public FSharpSourceFromFile internal (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+let createFromFile filePath = FSharpSourceFromFile (filePath) :> FSharpSource
+
+module doit =
+    createFromFile("Hello") |> ignore
+    printfn "Main program"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Main program"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Class Type visibility with computation expressions - private ctor`` (realSig) =
+
+        FSharp """
+module FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+
+type MyBuilder() =
+    member this.Bind(x, f) = f x
+    member this.Return(x) = x
+
+let my = new MyBuilder()
+
+[<AbstractClass>]
+type FSharpSource () =
+    abstract FilePath: string
+
+type public FSharpSourceFromFile private (filePath: string) =
+    inherit FSharpSource()
+
+    override _.FilePath = filePath
+
+    static public MakeOne() =
+        my {
+            let! file = new  FSharpSourceFromFile ("Hello, World")
+            return file
+        }
+
+let makeOne() = FSharpSourceFromFile.MakeOne()
+
+printfn $"{makeOne().FilePath}"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``Class Type visibility with lazy nested module - private`` (realSig) =
+
+        FSharp """
+module private TestReferences =
+
+    [<RequireQualifiedAccess>]
+    module NetStandard20 =
+        module Files =
+            let netStandard = lazy "Hello, World!!!"
+
+module doSomething =
+    printfn $"{TestReferences.NetStandard20.Files.netStandard.Value}"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World"
+        ]
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``module visibility - various`` (realSig) =
+
+        FSharp """
+module outer_default =
+    printfn $"outer_outer_default"
+
+module public outer_public =
+    printfn $"outer_public"
+
+module internal outer_internal =
+    printfn $"outer_internal"
+
+module private outer_private =
+    printfn $"outer_private"
+
+module doSomething =
+    printfn "Hello, World!"
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> withStdOutContainsAllInOrder [
+            "Hello, World"
+        ]
+
+
+    [<InlineData(true)>]        // RealSig
+    [<InlineData(false)>]       // Regular
+    [<Theory>]
+    let ``module visibility - Datum`` (realSig) =
+
+        FSharp """
+module Test6
+    module internal HelperModule = 
+            
+        type public Data = 
+            private
+                {
+                    Datum: int
+                }
+                    
+        let internal handle (data:Data): int = data.Datum
+            
+    module public Module =
+            
+        type public Data = 
+            private
+                {
+                    Thing: HelperModule.Data
+                }
+
+        let public getInt (data:Data): int = HelperModule.handle data.Thing               
+        """
+        |> withLangVersionPreview
+        |> withRealInternalSignature realSig
+        |> asLibrary
+        |> compile
+        |> shouldSucceed
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionStepping.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionStepping.fs
index b11679b96a6..3b748e2be23 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionStepping.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionStepping.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open Xunit
 open System.IO
@@ -18,43 +18,99 @@ module SeqExpressionStepping =
         |> verifyILBaseline
 
     //Retry SOURCE=SeqExpressionSteppingTest01.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest1.exe"	# SeqExpressionSteppingTest1.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"SeqExpressionSteppingTest01.fs"|])>]
-    let ``SeqExpressionSteppingTest01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"SeqExpressionSteppingTest01.fs"|])>]
+    let ``SeqExpressionSteppingTest01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    //Retry SOURCE=SeqExpressionSteppingTest01.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest1.exe"	# SeqExpressionSteppingTest1.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"SeqExpressionSteppingTest01.fs"|])>]
+    let ``SeqExpressionSteppingTest01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=SeqExpressionSteppingTest02.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest2.exe"	# SeqExpressionSteppingTest2.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"SeqExpressionSteppingTest02.fs"|])>]
+    let ``SeqExpressionSteppingTest02_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=SeqExpressionSteppingTest02.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest2.exe"	# SeqExpressionSteppingTest2.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"SeqExpressionSteppingTest02.fs"|])>]
-    let ``SeqExpressionSteppingTest02_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"SeqExpressionSteppingTest02.fs"|])>]
+    let ``SeqExpressionSteppingTest02_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     //SOURCE=SeqExpressionSteppingTest03.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest3.exe"	# SeqExpressionSteppingTest3.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"SeqExpressionSteppingTest03.fs"|])>]
-    let ``SeqExpressionSteppingTest03_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"SeqExpressionSteppingTest03.fs"|])>]
+    let ``SeqExpressionSteppingTest03_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    //SOURCE=SeqExpressionSteppingTest03.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest3.exe"	# SeqExpressionSteppingTest3.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"SeqExpressionSteppingTest03.fs"|])>]
+    let ``SeqExpressionSteppingTest03_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=SeqExpressionSteppingTest04.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest4.exe"	# SeqExpressionSteppingTest4.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"SeqExpressionSteppingTest04.fs"|])>]
+    let ``SeqExpressionSteppingTest04_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=SeqExpressionSteppingTest04.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest4.exe"	# SeqExpressionSteppingTest4.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"SeqExpressionSteppingTest04.fs"|])>]
-    let ``SeqExpressionSteppingTest04_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"SeqExpressionSteppingTest04.fs"|])>]
+    let ``SeqExpressionSteppingTest04_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     // SOURCE=SeqExpressionSteppingTest05.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest5.exe"	# SeqExpressionSteppingTest5.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"SeqExpressionSteppingTest05.fs"|])>]
-    let ``SeqExpressionSteppingTest05_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"SeqExpressionSteppingTest05.fs"|])>]
+    let ``SeqExpressionSteppingTest05_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    // SOURCE=SeqExpressionSteppingTest05.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest5.exe"	# SeqExpressionSteppingTest5.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"SeqExpressionSteppingTest05.fs"|])>]
+    let ``SeqExpressionSteppingTest05_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=SeqExpressionSteppingTest06.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest6.exe"	# SeqExpressionSteppingTest6.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"SeqExpressionSteppingTest06.fs"|])>]
+    let ``SeqExpressionSteppingTest06_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=SeqExpressionSteppingTest06.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest6.exe"	# SeqExpressionSteppingTest6.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"SeqExpressionSteppingTest06.fs"|])>]
-    let ``SeqExpressionSteppingTest06_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"SeqExpressionSteppingTest06.fs"|])>]
+    let ``SeqExpressionSteppingTest06_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=SeqExpressionSteppingTest07.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest7.exe"	# SeqExpressionSteppingTest7.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"SeqExpressionSteppingTest07.fs"|])>]
+    let ``SeqExpressionSteppingTest07_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=SeqExpressionSteppingTest07.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionSteppingTest7.exe"	# SeqExpressionSteppingTest7.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"SeqExpressionSteppingTest07.fs"|])>]
-    let ``SeqExpressionSteppingTest07_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"SeqExpressionSteppingTest07.fs"|])>]
+    let ``SeqExpressionSteppingTest07_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.RealInternalSignatureOff.il.bsl
similarity index 93%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.RealInternalSignatureOff.il.bsl
index 3df6547ccae..36ec2d96a52 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.RealInternalSignatureOff.il.bsl
@@ -76,8 +76,7 @@
         IL_0014:  ret
       } 
 
-      .method public strict virtual instance int32 
-              GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+      .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
       {
         
         .maxstack  8
@@ -116,8 +115,7 @@
         IL_003d:  ret
       } 
 
-      .method public strict virtual instance void 
-              Close() cil managed
+      .method public strict virtual instance void Close() cil managed
       {
         
         .maxstack  8
@@ -127,8 +125,7 @@
         IL_0007:  ret
       } 
 
-      .method public strict virtual instance bool 
-              get_CheckClose() cil managed
+      .method public strict virtual instance bool get_CheckClose() cil managed
       {
         
         .maxstack  8
@@ -157,8 +154,7 @@
         IL_0026:  ret
       } 
 
-      .method public strict virtual instance int32 
-              get_LastGenerated() cil managed
+      .method public strict virtual instance int32 get_LastGenerated() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -169,8 +165,7 @@
         IL_0006:  ret
       } 
 
-      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> 
-              GetFreshEnumerator() cil managed
+      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -185,8 +180,7 @@
 
     } 
 
-    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> 
-            f0() cil managed
+    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> f0() cil managed
     {
       
       .maxstack  8
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..3b2c45a9149
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest01.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,263 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed SeqExpressionSteppingTest1
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public SeqExpressionSteppingTest1
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested assembly beforefieldinit specialname f0@6
+           extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+      .field public int32 pc
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public int32 current
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname 
+              instance void  .ctor(int32 pc,
+                                   int32 current) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  stfld      int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::pc
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.2
+        IL_0009:  stfld      int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::current
+        IL_000e:  ldarg.0
+        IL_000f:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::pc
+        IL_0006:  ldc.i4.1
+        IL_0007:  sub
+        IL_0008:  switch     ( 
+                              IL_0017,
+                              IL_001a)
+        IL_0015:  br.s       IL_001d
+
+        IL_0017:  nop
+        IL_0018:  br.s       IL_002e
+
+        IL_001a:  nop
+        IL_001b:  br.s       IL_0035
+
+        IL_001d:  nop
+        IL_001e:  ldarg.0
+        IL_001f:  ldc.i4.1
+        IL_0020:  stfld      int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::pc
+        IL_0025:  ldarg.0
+        IL_0026:  ldc.i4.1
+        IL_0027:  stfld      int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::current
+        IL_002c:  ldc.i4.1
+        IL_002d:  ret
+
+        IL_002e:  ldarg.0
+        IL_002f:  ldc.i4.2
+        IL_0030:  stfld      int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::pc
+        IL_0035:  ldarg.0
+        IL_0036:  ldc.i4.0
+        IL_0037:  stfld      int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::current
+        IL_003c:  ldc.i4.0
+        IL_003d:  ret
+      } 
+
+      .method public strict virtual instance void Close() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.2
+        IL_0002:  stfld      int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::pc
+        IL_0007:  ret
+      } 
+
+      .method public strict virtual instance bool get_CheckClose() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::pc
+        IL_0006:  switch     ( 
+                              IL_0019,
+                              IL_001c,
+                              IL_001f)
+        IL_0017:  br.s       IL_0022
+
+        IL_0019:  nop
+        IL_001a:  br.s       IL_0025
+
+        IL_001c:  nop
+        IL_001d:  br.s       IL_0023
+
+        IL_001f:  nop
+        IL_0020:  br.s       IL_0025
+
+        IL_0022:  nop
+        IL_0023:  ldc.i4.0
+        IL_0024:  ret
+
+        IL_0025:  ldc.i4.0
+        IL_0026:  ret
+      } 
+
+      .method public strict virtual instance int32 get_LastGenerated() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::current
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldc.i4.0
+        IL_0001:  ldc.i4.0
+        IL_0002:  newobj     instance void SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::.ctor(int32,
+                                                                                                             int32)
+        IL_0007:  ret
+      } 
+
+    } 
+
+    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> f0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ldc.i4.0
+      IL_0002:  newobj     instance void SeqExpressionSteppingTest1/SeqExpressionSteppingTest1/f0@6::.ctor(int32,
+                                                                                                           int32)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest1::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest1::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  3
+      .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0)
+      IL_0000:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> SeqExpressionSteppingTest1/SeqExpressionSteppingTest1::f0()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  pop
+      IL_000d:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest1::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest1::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void SeqExpressionSteppingTest1/SeqExpressionSteppingTest1::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$SeqExpressionSteppingTest1
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void SeqExpressionSteppingTest1::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOff.il.bsl
similarity index 94%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOff.il.bsl
index 0c8731a0094..4400ae53886 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOff.il.bsl
@@ -76,8 +76,7 @@
         IL_0014:  ret
       } 
 
-      .method public strict virtual instance int32 
-              GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+      .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
       {
         
         .maxstack  6
@@ -137,8 +136,7 @@
         IL_0074:  ret
       } 
 
-      .method public strict virtual instance void 
-              Close() cil managed
+      .method public strict virtual instance void Close() cil managed
       {
         
         .maxstack  8
@@ -148,8 +146,7 @@
         IL_0007:  ret
       } 
 
-      .method public strict virtual instance bool 
-              get_CheckClose() cil managed
+      .method public strict virtual instance bool get_CheckClose() cil managed
       {
         
         .maxstack  8
@@ -185,8 +182,7 @@
         IL_002f:  ret
       } 
 
-      .method public strict virtual instance int32 
-              get_LastGenerated() cil managed
+      .method public strict virtual instance int32 get_LastGenerated() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -197,8 +193,7 @@
         IL_0006:  ret
       } 
 
-      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> 
-              GetFreshEnumerator() cil managed
+      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -213,8 +208,7 @@
 
     } 
 
-    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> 
-            f1() cil managed
+    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> f1() cil managed
     {
       
       .maxstack  8
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..c667f5ac064
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest02.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,291 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed SeqExpressionSteppingTest2
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public SeqExpressionSteppingTest2
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested assembly beforefieldinit specialname f1@5
+           extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+      .field public int32 pc
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public int32 current
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname 
+              instance void  .ctor(int32 pc,
+                                   int32 current) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  stfld      int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.2
+        IL_0009:  stfld      int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current
+        IL_000e:  ldarg.0
+        IL_000f:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+        IL_0014:  ret
+      } 
+
+      .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+      {
+        
+        .maxstack  6
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc
+        IL_0006:  ldc.i4.1
+        IL_0007:  sub
+        IL_0008:  switch     ( 
+                              IL_001b,
+                              IL_001e,
+                              IL_0021)
+        IL_0019:  br.s       IL_0024
+
+        IL_001b:  nop
+        IL_001c:  br.s       IL_0045
+
+        IL_001e:  nop
+        IL_001f:  br.s       IL_0065
+
+        IL_0021:  nop
+        IL_0022:  br.s       IL_006c
+
+        IL_0024:  nop
+        IL_0025:  ldstr      "hello"
+        IL_002a:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_002f:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0034:  pop
+        IL_0035:  ldarg.0
+        IL_0036:  ldc.i4.1
+        IL_0037:  stfld      int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc
+        IL_003c:  ldarg.0
+        IL_003d:  ldc.i4.1
+        IL_003e:  stfld      int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current
+        IL_0043:  ldc.i4.1
+        IL_0044:  ret
+
+        IL_0045:  ldstr      "goodbye"
+        IL_004a:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_004f:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0054:  pop
+        IL_0055:  ldarg.0
+        IL_0056:  ldc.i4.2
+        IL_0057:  stfld      int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc
+        IL_005c:  ldarg.0
+        IL_005d:  ldc.i4.2
+        IL_005e:  stfld      int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current
+        IL_0063:  ldc.i4.1
+        IL_0064:  ret
+
+        IL_0065:  ldarg.0
+        IL_0066:  ldc.i4.3
+        IL_0067:  stfld      int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc
+        IL_006c:  ldarg.0
+        IL_006d:  ldc.i4.0
+        IL_006e:  stfld      int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current
+        IL_0073:  ldc.i4.0
+        IL_0074:  ret
+      } 
+
+      .method public strict virtual instance void Close() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.3
+        IL_0002:  stfld      int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc
+        IL_0007:  ret
+      } 
+
+      .method public strict virtual instance bool get_CheckClose() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::pc
+        IL_0006:  switch     ( 
+                              IL_001d,
+                              IL_0020,
+                              IL_0023,
+                              IL_0026)
+        IL_001b:  br.s       IL_0029
+
+        IL_001d:  nop
+        IL_001e:  br.s       IL_002e
+
+        IL_0020:  nop
+        IL_0021:  br.s       IL_002c
+
+        IL_0023:  nop
+        IL_0024:  br.s       IL_002a
+
+        IL_0026:  nop
+        IL_0027:  br.s       IL_002e
+
+        IL_0029:  nop
+        IL_002a:  ldc.i4.0
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+      } 
+
+      .method public strict virtual instance int32 get_LastGenerated() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::current
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldc.i4.0
+        IL_0001:  ldc.i4.0
+        IL_0002:  newobj     instance void SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::.ctor(int32,
+                                                                                                             int32)
+        IL_0007:  ret
+      } 
+
+    } 
+
+    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> f1() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  ldc.i4.0
+      IL_0002:  newobj     instance void SeqExpressionSteppingTest2/SeqExpressionSteppingTest2/f1@5::.ctor(int32,
+                                                                                                           int32)
+      IL_0007:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest2::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest2::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  3
+      .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0)
+      IL_0000:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> SeqExpressionSteppingTest2/SeqExpressionSteppingTest2::f1()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  pop
+      IL_000d:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest2::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest2::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void SeqExpressionSteppingTest2/SeqExpressionSteppingTest2::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$SeqExpressionSteppingTest2
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void SeqExpressionSteppingTest2::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.RealInternalSignatureOff.il.bsl
similarity index 95%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.RealInternalSignatureOff.il.bsl
index f373770edee..61bdc63be2d 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.RealInternalSignatureOff.il.bsl
@@ -81,8 +81,7 @@
         IL_001b:  ret
       } 
 
-      .method public strict virtual instance int32 
-              GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+      .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
       {
         
         .maxstack  7
@@ -143,8 +142,7 @@
         IL_007f:  ret
       } 
 
-      .method public strict virtual instance void 
-              Close() cil managed
+      .method public strict virtual instance void Close() cil managed
       {
         
         .maxstack  8
@@ -154,8 +152,7 @@
         IL_0007:  ret
       } 
 
-      .method public strict virtual instance bool 
-              get_CheckClose() cil managed
+      .method public strict virtual instance bool get_CheckClose() cil managed
       {
         
         .maxstack  8
@@ -184,8 +181,7 @@
         IL_0026:  ret
       } 
 
-      .method public strict virtual instance int32 
-              get_LastGenerated() cil managed
+      .method public strict virtual instance int32 get_LastGenerated() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -196,8 +192,7 @@
         IL_0006:  ret
       } 
 
-      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> 
-              GetFreshEnumerator() cil managed
+      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -215,8 +210,7 @@
 
     } 
 
-    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> 
-            f2() cil managed
+    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> f2() cil managed
     {
       
       .maxstack  5
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..bd1abfe67c0
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest03.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,299 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed SeqExpressionSteppingTest3
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public SeqExpressionSteppingTest3
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested assembly beforefieldinit specialname f2@7
+           extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+      .field public int32 pc
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public int32 current
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x,
+                                   int32 pc,
+                                   int32 current) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::x
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.2
+        IL_0009:  stfld      int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::pc
+        IL_000e:  ldarg.0
+        IL_000f:  ldarg.3
+        IL_0010:  stfld      int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::current
+        IL_0015:  ldarg.0
+        IL_0016:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+        IL_001b:  ret
+      } 
+
+      .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+      {
+        
+        .maxstack  7
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::pc
+        IL_0006:  ldc.i4.1
+        IL_0007:  sub
+        IL_0008:  switch     ( 
+                              IL_0017,
+                              IL_001a)
+        IL_0015:  br.s       IL_001d
+
+        IL_0017:  nop
+        IL_0018:  br.s       IL_0062
+
+        IL_001a:  nop
+        IL_001b:  br.s       IL_0077
+
+        IL_001d:  nop
+        IL_001e:  br.s       IL_0062
+
+        IL_0020:  ldarg.0
+        IL_0021:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::x
+        IL_0026:  ldarg.0
+        IL_0027:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::x
+        IL_002c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_0031:  ldc.i4.1
+        IL_0032:  add
+        IL_0033:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_contents(!0)
+        IL_0038:  ldstr      "hello"
+        IL_003d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_0042:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0047:  pop
+        IL_0048:  ldarg.0
+        IL_0049:  ldc.i4.1
+        IL_004a:  stfld      int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::pc
+        IL_004f:  ldarg.0
+        IL_0050:  ldarg.0
+        IL_0051:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::x
+        IL_0056:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_005b:  stfld      int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::current
+        IL_0060:  ldc.i4.1
+        IL_0061:  ret
+
+        IL_0062:  ldarg.0
+        IL_0063:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::x
+        IL_0068:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_006d:  ldc.i4.4
+        IL_006e:  blt.s      IL_0020
+
+        IL_0070:  ldarg.0
+        IL_0071:  ldc.i4.2
+        IL_0072:  stfld      int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::pc
+        IL_0077:  ldarg.0
+        IL_0078:  ldc.i4.0
+        IL_0079:  stfld      int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::current
+        IL_007e:  ldc.i4.0
+        IL_007f:  ret
+      } 
+
+      .method public strict virtual instance void Close() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.2
+        IL_0002:  stfld      int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::pc
+        IL_0007:  ret
+      } 
+
+      .method public strict virtual instance bool get_CheckClose() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::pc
+        IL_0006:  switch     ( 
+                              IL_0019,
+                              IL_001c,
+                              IL_001f)
+        IL_0017:  br.s       IL_0022
+
+        IL_0019:  nop
+        IL_001a:  br.s       IL_0025
+
+        IL_001c:  nop
+        IL_001d:  br.s       IL_0023
+
+        IL_001f:  nop
+        IL_0020:  br.s       IL_0025
+
+        IL_0022:  nop
+        IL_0023:  ldc.i4.0
+        IL_0024:  ret
+
+        IL_0025:  ldc.i4.0
+        IL_0026:  ret
+      } 
+
+      .method public strict virtual instance int32 get_LastGenerated() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::current
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::x
+        IL_0006:  ldc.i4.0
+        IL_0007:  ldc.i4.0
+        IL_0008:  newobj     instance void SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>,
+                                                                                                             int32,
+                                                                                                             int32)
+        IL_000d:  ret
+      } 
+
+    } 
+
+    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> f2() cil managed
+    {
+      
+      .maxstack  5
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> V_0)
+      IL_0000:  ldc.i4.0
+      IL_0001:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::.ctor(!0)
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  ldc.i4.0
+      IL_0009:  ldc.i4.0
+      IL_000a:  newobj     instance void SeqExpressionSteppingTest3/SeqExpressionSteppingTest3/f2@7::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>,
+                                                                                                           int32,
+                                                                                                           int32)
+      IL_000f:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest3::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest3::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  3
+      .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0)
+      IL_0000:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> SeqExpressionSteppingTest3/SeqExpressionSteppingTest3::f2()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  pop
+      IL_000d:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest3::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest3::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void SeqExpressionSteppingTest3/SeqExpressionSteppingTest3::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$SeqExpressionSteppingTest3
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void SeqExpressionSteppingTest3::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.RealInternalSignatureOff.il.bsl
similarity index 95%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.RealInternalSignatureOff.il.bsl
index 929ee8a9d42..7a56bcf3e94 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.RealInternalSignatureOff.il.bsl
@@ -86,8 +86,7 @@
         IL_0023:  ret
       } 
 
-      .method public strict virtual instance int32 
-              GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+      .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
       {
         
         .maxstack  7
@@ -180,8 +179,7 @@
         IL_00d2:  ret
       } 
 
-      .method public strict virtual instance void 
-              Close() cil managed
+      .method public strict virtual instance void Close() cil managed
       {
         
         .maxstack  8
@@ -191,8 +189,7 @@
         IL_0007:  ret
       } 
 
-      .method public strict virtual instance bool 
-              get_CheckClose() cil managed
+      .method public strict virtual instance bool get_CheckClose() cil managed
       {
         
         .maxstack  8
@@ -228,8 +225,7 @@
         IL_002f:  ret
       } 
 
-      .method public strict virtual instance int32 
-              get_LastGenerated() cil managed
+      .method public strict virtual instance int32 get_LastGenerated() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -240,8 +236,7 @@
         IL_0006:  ret
       } 
 
-      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> 
-              GetFreshEnumerator() cil managed
+      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -260,8 +255,7 @@
 
     } 
 
-    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> 
-            f3() cil managed
+    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> f3() cil managed
     {
       
       .maxstack  8
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..a56865f2de9
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest04.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,342 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed SeqExpressionSteppingTest4
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public SeqExpressionSteppingTest4
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested assembly beforefieldinit specialname f3@6
+           extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> y
+      .field public int32 pc
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public int32 current
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> y,
+                                   int32 pc,
+                                   int32 current) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::x
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.2
+        IL_0009:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::y
+        IL_000e:  ldarg.0
+        IL_000f:  ldarg.3
+        IL_0010:  stfld      int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::pc
+        IL_0015:  ldarg.0
+        IL_0016:  ldarg.s    current
+        IL_0018:  stfld      int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::current
+        IL_001d:  ldarg.0
+        IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+        IL_0023:  ret
+      } 
+
+      .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (int32 V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::pc
+        IL_0006:  ldc.i4.1
+        IL_0007:  sub
+        IL_0008:  switch     ( 
+                              IL_001b,
+                              IL_001e,
+                              IL_0024)
+        IL_0019:  br.s       IL_002a
+
+        IL_001b:  nop
+        IL_001c:  br.s       IL_008d
+
+        IL_001e:  nop
+        IL_001f:  br         IL_00b5
+
+        IL_0024:  nop
+        IL_0025:  br         IL_00ca
+
+        IL_002a:  nop
+        IL_002b:  ldarg.0
+        IL_002c:  ldc.i4.0
+        IL_002d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::.ctor(!0)
+        IL_0032:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::x
+        IL_0037:  ldarg.0
+        IL_0038:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::x
+        IL_003d:  ldarg.0
+        IL_003e:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::x
+        IL_0043:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_0048:  ldc.i4.1
+        IL_0049:  add
+        IL_004a:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_contents(!0)
+        IL_004f:  ldarg.0
+        IL_0050:  ldc.i4.0
+        IL_0051:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::.ctor(!0)
+        IL_0056:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::y
+        IL_005b:  ldarg.0
+        IL_005c:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::y
+        IL_0061:  ldarg.0
+        IL_0062:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::y
+        IL_0067:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_006c:  ldc.i4.1
+        IL_006d:  add
+        IL_006e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_contents(!0)
+        IL_0073:  ldarg.0
+        IL_0074:  ldc.i4.1
+        IL_0075:  stfld      int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::pc
+        IL_007a:  ldarg.0
+        IL_007b:  ldarg.0
+        IL_007c:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::x
+        IL_0081:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_0086:  stfld      int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::current
+        IL_008b:  ldc.i4.1
+        IL_008c:  ret
+
+        IL_008d:  ldarg.0
+        IL_008e:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::x
+        IL_0093:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_0098:  ldarg.0
+        IL_0099:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::y
+        IL_009e:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_00a3:  add
+        IL_00a4:  stloc.0
+        IL_00a5:  ldarg.0
+        IL_00a6:  ldc.i4.2
+        IL_00a7:  stfld      int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::pc
+        IL_00ac:  ldarg.0
+        IL_00ad:  ldloc.0
+        IL_00ae:  stfld      int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::current
+        IL_00b3:  ldc.i4.1
+        IL_00b4:  ret
+
+        IL_00b5:  ldarg.0
+        IL_00b6:  ldnull
+        IL_00b7:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::y
+        IL_00bc:  ldarg.0
+        IL_00bd:  ldnull
+        IL_00be:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::x
+        IL_00c3:  ldarg.0
+        IL_00c4:  ldc.i4.3
+        IL_00c5:  stfld      int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::pc
+        IL_00ca:  ldarg.0
+        IL_00cb:  ldc.i4.0
+        IL_00cc:  stfld      int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::current
+        IL_00d1:  ldc.i4.0
+        IL_00d2:  ret
+      } 
+
+      .method public strict virtual instance void Close() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldc.i4.3
+        IL_0002:  stfld      int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::pc
+        IL_0007:  ret
+      } 
+
+      .method public strict virtual instance bool get_CheckClose() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::pc
+        IL_0006:  switch     ( 
+                              IL_001d,
+                              IL_0020,
+                              IL_0023,
+                              IL_0026)
+        IL_001b:  br.s       IL_0029
+
+        IL_001d:  nop
+        IL_001e:  br.s       IL_002e
+
+        IL_0020:  nop
+        IL_0021:  br.s       IL_002c
+
+        IL_0023:  nop
+        IL_0024:  br.s       IL_002a
+
+        IL_0026:  nop
+        IL_0027:  br.s       IL_002e
+
+        IL_0029:  nop
+        IL_002a:  ldc.i4.0
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+      } 
+
+      .method public strict virtual instance int32 get_LastGenerated() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::current
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldnull
+        IL_0001:  ldnull
+        IL_0002:  ldc.i4.0
+        IL_0003:  ldc.i4.0
+        IL_0004:  newobj     instance void SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>,
+                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>,
+                                                                                                             int32,
+                                                                                                             int32)
+        IL_0009:  ret
+      } 
+
+    } 
+
+    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> f3() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldnull
+      IL_0002:  ldc.i4.0
+      IL_0003:  ldc.i4.0
+      IL_0004:  newobj     instance void SeqExpressionSteppingTest4/SeqExpressionSteppingTest4/f3@6::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>,
+                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>,
+                                                                                                           int32,
+                                                                                                           int32)
+      IL_0009:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest4::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest4::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  3
+      .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0)
+      IL_0000:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> SeqExpressionSteppingTest4/SeqExpressionSteppingTest4::f3()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  pop
+      IL_000d:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest4::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest4::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void SeqExpressionSteppingTest4/SeqExpressionSteppingTest4::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$SeqExpressionSteppingTest4
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void SeqExpressionSteppingTest4::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.RealInternalSignatureOff.il.bsl
similarity index 96%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.RealInternalSignatureOff.il.bsl
index f3d75f7ae55..dcf9a44b123 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.RealInternalSignatureOff.il.bsl
@@ -86,8 +86,7 @@
         IL_0023:  ret
       } 
 
-      .method public strict virtual instance int32 
-              GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+      .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
       {
         
         .maxstack  7
@@ -194,8 +193,7 @@
         IL_00fa:  ret
       } 
 
-      .method public strict virtual instance void 
-              Close() cil managed
+      .method public strict virtual instance void Close() cil managed
       {
         
         .maxstack  7
@@ -291,8 +289,7 @@
         IL_00a4:  ret
       } 
 
-      .method public strict virtual instance bool 
-              get_CheckClose() cil managed
+      .method public strict virtual instance bool get_CheckClose() cil managed
       {
         
         .maxstack  8
@@ -335,8 +332,7 @@
         IL_0038:  ret
       } 
 
-      .method public strict virtual instance int32 
-              get_LastGenerated() cil managed
+      .method public strict virtual instance int32 get_LastGenerated() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -347,8 +343,7 @@
         IL_0006:  ret
       } 
 
-      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> 
-              GetFreshEnumerator() cil managed
+      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -367,8 +362,7 @@
 
     } 
 
-    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> 
-            f4() cil managed
+    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> f4() cil managed
     {
       
       .maxstack  8
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..fca2f21dd75
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest05.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,449 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed SeqExpressionSteppingTest5
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public SeqExpressionSteppingTest5
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested assembly beforefieldinit specialname f4@6
+           extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x
+      .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> y
+      .field public int32 pc
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public int32 current
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname 
+              instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> x,
+                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> y,
+                                   int32 pc,
+                                   int32 current) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.2
+        IL_0009:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::y
+        IL_000e:  ldarg.0
+        IL_000f:  ldarg.3
+        IL_0010:  stfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc
+        IL_0015:  ldarg.0
+        IL_0016:  ldarg.s    current
+        IL_0018:  stfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::current
+        IL_001d:  ldarg.0
+        IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+        IL_0023:  ret
+      } 
+
+      .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+      {
+        
+        .maxstack  7
+        .locals init (int32 V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc
+        IL_0006:  ldc.i4.1
+        IL_0007:  sub
+        IL_0008:  switch     ( 
+                              IL_001f,
+                              IL_0025,
+                              IL_0028,
+                              IL_002e)
+        IL_001d:  br.s       IL_0034
+
+        IL_001f:  nop
+        IL_0020:  br         IL_00b5
+
+        IL_0025:  nop
+        IL_0026:  br.s       IL_0086
+
+        IL_0028:  nop
+        IL_0029:  br         IL_00ae
+
+        IL_002e:  nop
+        IL_002f:  br         IL_00f2
+
+        IL_0034:  nop
+        IL_0035:  ldarg.0
+        IL_0036:  ldc.i4.0
+        IL_0037:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::.ctor(!0)
+        IL_003c:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x
+        IL_0041:  ldarg.0
+        IL_0042:  ldc.i4.1
+        IL_0043:  stfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc
+        IL_0048:  ldarg.0
+        IL_0049:  ldc.i4.0
+        IL_004a:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::.ctor(!0)
+        IL_004f:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::y
+        IL_0054:  ldarg.0
+        IL_0055:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::y
+        IL_005a:  ldarg.0
+        IL_005b:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::y
+        IL_0060:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_0065:  ldc.i4.1
+        IL_0066:  add
+        IL_0067:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_contents(!0)
+        IL_006c:  ldarg.0
+        IL_006d:  ldc.i4.2
+        IL_006e:  stfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc
+        IL_0073:  ldarg.0
+        IL_0074:  ldarg.0
+        IL_0075:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x
+        IL_007a:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_007f:  stfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::current
+        IL_0084:  ldc.i4.1
+        IL_0085:  ret
+
+        IL_0086:  ldarg.0
+        IL_0087:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x
+        IL_008c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_0091:  ldarg.0
+        IL_0092:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::y
+        IL_0097:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_009c:  add
+        IL_009d:  stloc.0
+        IL_009e:  ldarg.0
+        IL_009f:  ldc.i4.3
+        IL_00a0:  stfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc
+        IL_00a5:  ldarg.0
+        IL_00a6:  ldloc.0
+        IL_00a7:  stfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::current
+        IL_00ac:  ldc.i4.1
+        IL_00ad:  ret
+
+        IL_00ae:  ldarg.0
+        IL_00af:  ldnull
+        IL_00b0:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::y
+        IL_00b5:  ldarg.0
+        IL_00b6:  ldc.i4.4
+        IL_00b7:  stfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc
+        IL_00bc:  ldarg.0
+        IL_00bd:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x
+        IL_00c2:  ldarg.0
+        IL_00c3:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x
+        IL_00c8:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+        IL_00cd:  ldc.i4.1
+        IL_00ce:  add
+        IL_00cf:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_contents(!0)
+        IL_00d4:  ldstr      "done"
+        IL_00d9:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_00de:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_00e3:  pop
+        IL_00e4:  ldarg.0
+        IL_00e5:  ldnull
+        IL_00e6:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x
+        IL_00eb:  ldarg.0
+        IL_00ec:  ldc.i4.4
+        IL_00ed:  stfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc
+        IL_00f2:  ldarg.0
+        IL_00f3:  ldc.i4.0
+        IL_00f4:  stfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::current
+        IL_00f9:  ldc.i4.0
+        IL_00fa:  ret
+      } 
+
+      .method public strict virtual instance void Close() cil managed
+      {
+        
+        .maxstack  7
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc
+        IL_0006:  ldc.i4.4
+        IL_0007:  sub
+        IL_0008:  switch     ( 
+                              IL_0013)
+        IL_0011:  br.s       IL_0019
+
+        IL_0013:  nop
+        IL_0014:  br         IL_009f
+
+        IL_0019:  nop
+        .try
+        {
+          IL_001a:  ldarg.0
+          IL_001b:  ldfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc
+          IL_0020:  switch     ( 
+                                IL_003b,
+                                IL_003e,
+                                IL_0041,
+                                IL_0044,
+                                IL_0047)
+          IL_0039:  br.s       IL_004a
+
+          IL_003b:  nop
+          IL_003c:  br.s       IL_007f
+
+          IL_003e:  nop
+          IL_003f:  br.s       IL_004f
+
+          IL_0041:  nop
+          IL_0042:  br.s       IL_004e
+
+          IL_0044:  nop
+          IL_0045:  br.s       IL_004b
+
+          IL_0047:  nop
+          IL_0048:  br.s       IL_007f
+
+          IL_004a:  nop
+          IL_004b:  nop
+          IL_004c:  br.s       IL_004f
+
+          IL_004e:  nop
+          IL_004f:  ldarg.0
+          IL_0050:  ldc.i4.4
+          IL_0051:  stfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc
+          IL_0056:  ldarg.0
+          IL_0057:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x
+          IL_005c:  ldarg.0
+          IL_005d:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32> SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::x
+          IL_0062:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::get_contents()
+          IL_0067:  ldc.i4.1
+          IL_0068:  add
+          IL_0069:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>::set_contents(!0)
+          IL_006e:  ldstr      "done"
+          IL_0073:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+          IL_0078:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+          IL_007d:  pop
+          IL_007e:  nop
+          IL_007f:  ldarg.0
+          IL_0080:  ldc.i4.4
+          IL_0081:  stfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc
+          IL_0086:  ldarg.0
+          IL_0087:  ldc.i4.0
+          IL_0088:  stfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::current
+          IL_008d:  leave.s    IL_0099
+
+        }  
+        catch [runtime]System.Object 
+        {
+          IL_008f:  castclass  [runtime]System.Exception
+          IL_0094:  stloc.1
+          IL_0095:  ldloc.1
+          IL_0096:  stloc.0
+          IL_0097:  leave.s    IL_0099
+
+        }  
+        IL_0099:  nop
+        IL_009a:  br         IL_0000
+
+        IL_009f:  ldloc.0
+        IL_00a0:  brfalse.s  IL_00a4
+
+        IL_00a2:  ldloc.0
+        IL_00a3:  throw
+
+        IL_00a4:  ret
+      } 
+
+      .method public strict virtual instance bool get_CheckClose() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::pc
+        IL_0006:  switch     ( 
+                              IL_0021,
+                              IL_0024,
+                              IL_0027,
+                              IL_002a,
+                              IL_002d)
+        IL_001f:  br.s       IL_0030
+
+        IL_0021:  nop
+        IL_0022:  br.s       IL_0037
+
+        IL_0024:  nop
+        IL_0025:  br.s       IL_0035
+
+        IL_0027:  nop
+        IL_0028:  br.s       IL_0033
+
+        IL_002a:  nop
+        IL_002b:  br.s       IL_0031
+
+        IL_002d:  nop
+        IL_002e:  br.s       IL_0037
+
+        IL_0030:  nop
+        IL_0031:  ldc.i4.1
+        IL_0032:  ret
+
+        IL_0033:  ldc.i4.1
+        IL_0034:  ret
+
+        IL_0035:  ldc.i4.1
+        IL_0036:  ret
+
+        IL_0037:  ldc.i4.0
+        IL_0038:  ret
+      } 
+
+      .method public strict virtual instance int32 get_LastGenerated() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::current
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldnull
+        IL_0001:  ldnull
+        IL_0002:  ldc.i4.0
+        IL_0003:  ldc.i4.0
+        IL_0004:  newobj     instance void SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>,
+                                                                                                             class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>,
+                                                                                                             int32,
+                                                                                                             int32)
+        IL_0009:  ret
+      } 
+
+    } 
+
+    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> f4() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldnull
+      IL_0002:  ldc.i4.0
+      IL_0003:  ldc.i4.0
+      IL_0004:  newobj     instance void SeqExpressionSteppingTest5/SeqExpressionSteppingTest5/f4@6::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>,
+                                                                                                           class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<int32>,
+                                                                                                           int32,
+                                                                                                           int32)
+      IL_0009:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest5::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest5::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  3
+      .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0)
+      IL_0000:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> SeqExpressionSteppingTest5/SeqExpressionSteppingTest5::f4()
+      IL_0005:  stloc.0
+      IL_0006:  ldloc.0
+      IL_0007:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_000c:  pop
+      IL_000d:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest5::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest5::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void SeqExpressionSteppingTest5/SeqExpressionSteppingTest5::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$SeqExpressionSteppingTest5
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void SeqExpressionSteppingTest5::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.RealInternalSignatureOff.il.bsl
similarity index 97%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.RealInternalSignatureOff.il.bsl
index a7bc0f97c68..e7288a13fd6 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.RealInternalSignatureOff.il.bsl
@@ -92,8 +92,7 @@
         IL_0023:  ret
       } 
 
-      .method public strict virtual instance int32 
-              GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+      .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
       {
         
         .maxstack  6
@@ -219,8 +218,7 @@
         IL_0123:  ret
       } 
 
-      .method public strict virtual instance void 
-              Close() cil managed
+      .method public strict virtual instance void Close() cil managed
       {
         
         .maxstack  6
@@ -320,8 +318,7 @@
         IL_00a3:  ret
       } 
 
-      .method public strict virtual instance bool 
-              get_CheckClose() cil managed
+      .method public strict virtual instance bool get_CheckClose() cil managed
       {
         
         .maxstack  5
@@ -371,8 +368,7 @@
         IL_0041:  ret
       } 
 
-      .method public strict virtual instance int32 
-              get_LastGenerated() cil managed
+      .method public strict virtual instance int32 get_LastGenerated() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -383,8 +379,7 @@
         IL_0006:  ret
       } 
 
-      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> 
-              GetFreshEnumerator() cil managed
+      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
       {
         .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
         .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -403,8 +398,7 @@
 
     } 
 
-    .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
-            get_es() cil managed
+    .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_es() cil managed
     {
       
       .maxstack  8
@@ -412,8 +406,7 @@
       IL_0005:  ret
     } 
 
-    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> 
-            f7() cil managed
+    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> f7() cil managed
     {
       
       .maxstack  8
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..343d2d040f7
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest06.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,512 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed SeqExpressionSteppingTest6
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public SeqExpressionSteppingTest6
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested assembly beforefieldinit specialname f7@6
+           extends class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+      .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum'
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public class [runtime]System.Collections.Generic.IEnumerator`1<int32> enum0
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public int32 pc
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .field public int32 current
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32> 'enum',
+                                   class [runtime]System.Collections.Generic.IEnumerator`1<int32> enum0,
+                                   int32 pc,
+                                   int32 current) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::'enum'
+        IL_0007:  ldarg.0
+        IL_0008:  ldarg.2
+        IL_0009:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::enum0
+        IL_000e:  ldarg.0
+        IL_000f:  ldarg.3
+        IL_0010:  stfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc
+        IL_0015:  ldarg.0
+        IL_0016:  ldarg.s    current
+        IL_0018:  stfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::current
+        IL_001d:  ldarg.0
+        IL_001e:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.GeneratedSequenceBase`1<int32>::.ctor()
+        IL_0023:  ret
+      } 
+
+      .method public strict virtual instance int32 GenerateNext(class [runtime]System.Collections.Generic.IEnumerable`1<int32>& next) cil managed
+      {
+        
+        .maxstack  6
+        .locals init (int32 V_0,
+                 int32 V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc
+        IL_0006:  ldc.i4.1
+        IL_0007:  sub
+        IL_0008:  switch     ( 
+                              IL_0023,
+                              IL_0026,
+                              IL_0029,
+                              IL_002f,
+                              IL_0035)
+        IL_0021:  br.s       IL_003b
+
+        IL_0023:  nop
+        IL_0024:  br.s       IL_008e
+
+        IL_0026:  nop
+        IL_0027:  br.s       IL_0081
+
+        IL_0029:  nop
+        IL_002a:  br         IL_00fa
+
+        IL_002f:  nop
+        IL_0030:  br         IL_00ed
+
+        IL_0035:  nop
+        IL_0036:  br         IL_011b
+
+        IL_003b:  nop
+        IL_003c:  ldarg.0
+        IL_003d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6::get_es()
+        IL_0042:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+        IL_0047:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::'enum'
+        IL_004c:  ldarg.0
+        IL_004d:  ldc.i4.1
+        IL_004e:  stfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc
+        IL_0053:  br.s       IL_0081
+
+        IL_0055:  ldarg.0
+        IL_0056:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::'enum'
+        IL_005b:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+        IL_0060:  stloc.0
+        IL_0061:  ldstr      "hello"
+        IL_0066:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_006b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_0070:  pop
+        IL_0071:  ldarg.0
+        IL_0072:  ldc.i4.2
+        IL_0073:  stfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc
+        IL_0078:  ldarg.0
+        IL_0079:  ldloc.0
+        IL_007a:  stfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::current
+        IL_007f:  ldc.i4.1
+        IL_0080:  ret
+
+        IL_0081:  ldarg.0
+        IL_0082:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::'enum'
+        IL_0087:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+        IL_008c:  brtrue.s   IL_0055
+
+        IL_008e:  ldarg.0
+        IL_008f:  ldc.i4.5
+        IL_0090:  stfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc
+        IL_0095:  ldarg.0
+        IL_0096:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::'enum'
+        IL_009b:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_00a0:  nop
+        IL_00a1:  ldarg.0
+        IL_00a2:  ldnull
+        IL_00a3:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::'enum'
+        IL_00a8:  ldarg.0
+        IL_00a9:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6::get_es()
+        IL_00ae:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+        IL_00b3:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::enum0
+        IL_00b8:  ldarg.0
+        IL_00b9:  ldc.i4.3
+        IL_00ba:  stfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc
+        IL_00bf:  br.s       IL_00ed
+
+        IL_00c1:  ldarg.0
+        IL_00c2:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::enum0
+        IL_00c7:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+        IL_00cc:  stloc.1
+        IL_00cd:  ldstr      "goodbye"
+        IL_00d2:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+        IL_00d7:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+        IL_00dc:  pop
+        IL_00dd:  ldarg.0
+        IL_00de:  ldc.i4.4
+        IL_00df:  stfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc
+        IL_00e4:  ldarg.0
+        IL_00e5:  ldloc.1
+        IL_00e6:  stfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::current
+        IL_00eb:  ldc.i4.1
+        IL_00ec:  ret
+
+        IL_00ed:  ldarg.0
+        IL_00ee:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::enum0
+        IL_00f3:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+        IL_00f8:  brtrue.s   IL_00c1
+
+        IL_00fa:  ldarg.0
+        IL_00fb:  ldc.i4.5
+        IL_00fc:  stfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc
+        IL_0101:  ldarg.0
+        IL_0102:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::enum0
+        IL_0107:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+        IL_010c:  nop
+        IL_010d:  ldarg.0
+        IL_010e:  ldnull
+        IL_010f:  stfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::enum0
+        IL_0114:  ldarg.0
+        IL_0115:  ldc.i4.5
+        IL_0116:  stfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc
+        IL_011b:  ldarg.0
+        IL_011c:  ldc.i4.0
+        IL_011d:  stfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::current
+        IL_0122:  ldc.i4.0
+        IL_0123:  ret
+      } 
+
+      .method public strict virtual instance void Close() cil managed
+      {
+        
+        .maxstack  6
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc
+        IL_0006:  ldc.i4.5
+        IL_0007:  sub
+        IL_0008:  switch     ( 
+                              IL_0013)
+        IL_0011:  br.s       IL_0019
+
+        IL_0013:  nop
+        IL_0014:  br         IL_009e
+
+        IL_0019:  nop
+        .try
+        {
+          IL_001a:  ldarg.0
+          IL_001b:  ldfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc
+          IL_0020:  switch     ( 
+                                IL_003f,
+                                IL_0042,
+                                IL_0045,
+                                IL_0048,
+                                IL_004b,
+                                IL_004e)
+          IL_003d:  br.s       IL_0051
+
+          IL_003f:  nop
+          IL_0040:  br.s       IL_007e
+
+          IL_0042:  nop
+          IL_0043:  br.s       IL_006a
+
+          IL_0045:  nop
+          IL_0046:  br.s       IL_0069
+
+          IL_0048:  nop
+          IL_0049:  br.s       IL_0053
+
+          IL_004b:  nop
+          IL_004c:  br.s       IL_0052
+
+          IL_004e:  nop
+          IL_004f:  br.s       IL_007e
+
+          IL_0051:  nop
+          IL_0052:  nop
+          IL_0053:  ldarg.0
+          IL_0054:  ldc.i4.5
+          IL_0055:  stfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc
+          IL_005a:  ldarg.0
+          IL_005b:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::enum0
+          IL_0060:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+          IL_0065:  nop
+          IL_0066:  nop
+          IL_0067:  br.s       IL_007e
+
+          IL_0069:  nop
+          IL_006a:  ldarg.0
+          IL_006b:  ldc.i4.5
+          IL_006c:  stfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc
+          IL_0071:  ldarg.0
+          IL_0072:  ldfld      class [runtime]System.Collections.Generic.IEnumerator`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::'enum'
+          IL_0077:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::Dispose<class [runtime]System.Collections.Generic.IEnumerator`1<int32>>(!!0)
+          IL_007c:  nop
+          IL_007d:  nop
+          IL_007e:  ldarg.0
+          IL_007f:  ldc.i4.5
+          IL_0080:  stfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc
+          IL_0085:  ldarg.0
+          IL_0086:  ldc.i4.0
+          IL_0087:  stfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::current
+          IL_008c:  leave.s    IL_0098
+
+        }  
+        catch [runtime]System.Object 
+        {
+          IL_008e:  castclass  [runtime]System.Exception
+          IL_0093:  stloc.1
+          IL_0094:  ldloc.1
+          IL_0095:  stloc.0
+          IL_0096:  leave.s    IL_0098
+
+        }  
+        IL_0098:  nop
+        IL_0099:  br         IL_0000
+
+        IL_009e:  ldloc.0
+        IL_009f:  brfalse.s  IL_00a3
+
+        IL_00a1:  ldloc.0
+        IL_00a2:  throw
+
+        IL_00a3:  ret
+      } 
+
+      .method public strict virtual instance bool get_CheckClose() cil managed
+      {
+        
+        .maxstack  5
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::pc
+        IL_0006:  switch     ( 
+                              IL_0025,
+                              IL_0028,
+                              IL_002b,
+                              IL_002e,
+                              IL_0031,
+                              IL_0034)
+        IL_0023:  br.s       IL_0037
+
+        IL_0025:  nop
+        IL_0026:  br.s       IL_0040
+
+        IL_0028:  nop
+        IL_0029:  br.s       IL_003e
+
+        IL_002b:  nop
+        IL_002c:  br.s       IL_003c
+
+        IL_002e:  nop
+        IL_002f:  br.s       IL_003a
+
+        IL_0031:  nop
+        IL_0032:  br.s       IL_0038
+
+        IL_0034:  nop
+        IL_0035:  br.s       IL_0040
+
+        IL_0037:  nop
+        IL_0038:  ldc.i4.1
+        IL_0039:  ret
+
+        IL_003a:  ldc.i4.1
+        IL_003b:  ret
+
+        IL_003c:  ldc.i4.1
+        IL_003d:  ret
+
+        IL_003e:  ldc.i4.1
+        IL_003f:  ret
+
+        IL_0040:  ldc.i4.0
+        IL_0041:  ret
+      } 
+
+      .method public strict virtual instance int32 get_LastGenerated() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::current
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance class [runtime]System.Collections.Generic.IEnumerator`1<int32> GetFreshEnumerator() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldnull
+        IL_0001:  ldnull
+        IL_0002:  ldc.i4.0
+        IL_0003:  ldc.i4.0
+        IL_0004:  newobj     instance void SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                             class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                             int32,
+                                                                                                             int32)
+        IL_0009:  ret
+      } 
+
+    } 
+
+    .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> es@4
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_es() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6::es@4
+      IL_0005:  ret
+    } 
+
+    .method public static class [runtime]System.Collections.Generic.IEnumerable`1<int32> f7() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldnull
+      IL_0001:  ldnull
+      IL_0002:  ldc.i4.0
+      IL_0003:  ldc.i4.0
+      IL_0004:  newobj     instance void SeqExpressionSteppingTest6/SeqExpressionSteppingTest6/f7@6::.ctor(class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                           class [runtime]System.Collections.Generic.IEnumerator`1<int32>,
+                                                                                                           int32,
+                                                                                                           int32)
+      IL_0009:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest6::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest6::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0)
+      IL_0000:  ldc.i4.1
+      IL_0001:  ldc.i4.2
+      IL_0002:  ldc.i4.3
+      IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+      IL_0008:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_0017:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6::es@4
+      IL_001c:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6::f7()
+      IL_0021:  stloc.0
+      IL_0022:  ldloc.0
+      IL_0023:  call       int32 [FSharp.Core]Microsoft.FSharp.Collections.SeqModule::Length<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>)
+      IL_0028:  pop
+      IL_0029:  ret
+    } 
+
+    .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+            es()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+      .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> SeqExpressionSteppingTest6/SeqExpressionSteppingTest6::get_es()
+    } 
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest6::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest6::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void SeqExpressionSteppingTest6/SeqExpressionSteppingTest6::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$SeqExpressionSteppingTest6
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void SeqExpressionSteppingTest6::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.net472.debug.bsl
similarity index 99%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.net472.debug.bsl
index d96fed2e849..86cc7e04485 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.net472.debug.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.net472.debug.bsl
@@ -43,8 +43,7 @@
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
-  .method public specialname static int32 
-          get_r() cil managed
+  .method public specialname static int32 get_r() cil managed
   {
     
     .maxstack  8
@@ -52,8 +51,7 @@
     IL_0005:  ret
   } 
 
-  .method public specialname static void 
-          set_r(int32 'value') cil managed
+  .method public specialname static void set_r(int32 'value') cil managed
   {
     
     .maxstack  8
@@ -62,8 +60,7 @@
     IL_0006:  ret
   } 
 
-  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a> 
-          f<a>() cil managed
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a> f<a>() cil managed
   {
     
     .maxstack  5
@@ -673,8 +670,7 @@
     IL_0032:  ret
   } 
 
-  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
-          ListExpressionSteppingTest7() cil managed
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest7() cil managed
   {
     
     .maxstack  5
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.net472.release.bsl
similarity index 99%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.net472.release.bsl
index d96fed2e849..86cc7e04485 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.net472.release.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.net472.release.bsl
@@ -43,8 +43,7 @@
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
-  .method public specialname static int32 
-          get_r() cil managed
+  .method public specialname static int32 get_r() cil managed
   {
     
     .maxstack  8
@@ -52,8 +51,7 @@
     IL_0005:  ret
   } 
 
-  .method public specialname static void 
-          set_r(int32 'value') cil managed
+  .method public specialname static void set_r(int32 'value') cil managed
   {
     
     .maxstack  8
@@ -62,8 +60,7 @@
     IL_0006:  ret
   } 
 
-  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a> 
-          f<a>() cil managed
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a> f<a>() cil managed
   {
     
     .maxstack  5
@@ -673,8 +670,7 @@
     IL_0032:  ret
   } 
 
-  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
-          ListExpressionSteppingTest7() cil managed
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest7() cil managed
   {
     
     .maxstack  5
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.netcore.debug.bsl
similarity index 99%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.netcore.debug.bsl
index fd8f60ce0c4..bb5909fc008 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.netcore.debug.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.netcore.debug.bsl
@@ -44,8 +44,7 @@
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
-  .method public specialname static int32 
-          get_r() cil managed
+  .method public specialname static int32 get_r() cil managed
   {
     
     .maxstack  8
@@ -53,8 +52,7 @@
     IL_0005:  ret
   } 
 
-  .method public specialname static void 
-          set_r(int32 'value') cil managed
+  .method public specialname static void set_r(int32 'value') cil managed
   {
     
     .maxstack  8
@@ -63,8 +61,7 @@
     IL_0006:  ret
   } 
 
-  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a> 
-          f<a>() cil managed
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a> f<a>() cil managed
   {
     
     .maxstack  5
@@ -674,8 +671,7 @@
     IL_0032:  ret
   } 
 
-  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
-          ListExpressionSteppingTest7() cil managed
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest7() cil managed
   {
     
     .maxstack  5
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.netcore.release.bsl
similarity index 99%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.netcore.release.bsl
index fd8f60ce0c4..bb5909fc008 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.il.netcore.release.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOff.il.netcore.release.bsl
@@ -44,8 +44,7 @@
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
-  .method public specialname static int32 
-          get_r() cil managed
+  .method public specialname static int32 get_r() cil managed
   {
     
     .maxstack  8
@@ -53,8 +52,7 @@
     IL_0005:  ret
   } 
 
-  .method public specialname static void 
-          set_r(int32 'value') cil managed
+  .method public specialname static void set_r(int32 'value') cil managed
   {
     
     .maxstack  8
@@ -63,8 +61,7 @@
     IL_0006:  ret
   } 
 
-  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a> 
-          f<a>() cil managed
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a> f<a>() cil managed
   {
     
     .maxstack  5
@@ -674,8 +671,7 @@
     IL_0032:  ret
   } 
 
-  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
-          ListExpressionSteppingTest7() cil managed
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest7() cil managed
   {
     
     .maxstack  5
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.net472.debug.bsl
new file mode 100644
index 00000000000..f0812837c64
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.net472.debug.bsl
@@ -0,0 +1,830 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed SeqExpressionSteppingTest7
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly int32 r@4
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32 get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 SeqExpressionSteppingTest7::r@4
+    IL_0005:  ret
+  } 
+
+  .method public specialname static void set_r(int32 'value') cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  stsfld     int32 SeqExpressionSteppingTest7::r@4
+    IL_0006:  ret
+  } 
+
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a> f<a>() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<!!a> V_0,
+             string V_1)
+    IL_0000:  nop
+    IL_0001:  nop
+    IL_0002:  call       int32 SeqExpressionSteppingTest7::get_r()
+    IL_0007:  ldc.i4.1
+    IL_0008:  add
+    IL_0009:  call       void SeqExpressionSteppingTest7::set_r(int32)
+    IL_000e:  ldc.i4.1
+    IL_000f:  brfalse.s  IL_0034
+
+    IL_0011:  ldstr      ""
+    IL_0016:  stloc.1
+    IL_0017:  ldloca.s   V_0
+    IL_0019:  ldc.i4.0
+    IL_001a:  brfalse.s  IL_0024
+
+    IL_001c:  ldnull
+    IL_001d:  unbox.any  class [runtime]System.Collections.Generic.IEnumerable`1<!!a>
+    IL_0022:  br.s       IL_002b
+
+    IL_0024:  ldloc.1
+    IL_0025:  call       class [runtime]System.Exception [FSharp.Core]Microsoft.FSharp.Core.Operators::Failure(string)
+    IL_002a:  throw
+
+    IL_002b:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<!!a>::AddMany(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0030:  nop
+    IL_0031:  nop
+    IL_0032:  br.s       IL_0035
+
+    IL_0034:  nop
+    IL_0035:  ldloca.s   V_0
+    IL_0037:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<!!a>::Close()
+    IL_003c:  ret
+  } 
+
+  .method public static void  testSimpleForEachSeqLoopWithOneStatement(class [runtime]System.Collections.Generic.IEnumerable`1<object[]> inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<object[]> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<object[]> V_1,
+             object[] V_2,
+             class [runtime]System.IDisposable V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<object[]>::GetEnumerator()
+    IL_0008:  stloc.1
+    .try
+    {
+      IL_0009:  br.s       IL_001d
+
+      IL_000b:  ldloc.1
+      IL_000c:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<object[]>::get_Current()
+      IL_0011:  stloc.2
+      IL_0012:  ldstr      "{0}"
+      IL_0017:  ldloc.2
+      IL_0018:  call       void [runtime]System.Console::WriteLine(string,
+                                                                    object[])
+      IL_001d:  ldloc.1
+      IL_001e:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0023:  brtrue.s   IL_000b
+
+      IL_0025:  leave.s    IL_0039
+
+    }  
+    finally
+    {
+      IL_0027:  ldloc.1
+      IL_0028:  isinst     [runtime]System.IDisposable
+      IL_002d:  stloc.3
+      IL_002e:  ldloc.3
+      IL_002f:  brfalse.s  IL_0038
+
+      IL_0031:  ldloc.3
+      IL_0032:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0037:  endfinally
+      IL_0038:  endfinally
+    }  
+    IL_0039:  ret
+  } 
+
+  .method public static void  testSimpleForEachSeqLoopWithTwoStatements(class [runtime]System.Collections.Generic.IEnumerable`1<object[]> inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<object[]> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<object[]> V_1,
+             object[] V_2,
+             class [runtime]System.IDisposable V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<object[]>::GetEnumerator()
+    IL_0008:  stloc.1
+    .try
+    {
+      IL_0009:  br.s       IL_0028
+
+      IL_000b:  ldloc.1
+      IL_000c:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<object[]>::get_Current()
+      IL_0011:  stloc.2
+      IL_0012:  ldstr      "{0}"
+      IL_0017:  ldloc.2
+      IL_0018:  call       void [runtime]System.Console::WriteLine(string,
+                                                                    object[])
+      IL_001d:  ldstr      "{0}"
+      IL_0022:  ldloc.2
+      IL_0023:  call       void [runtime]System.Console::WriteLine(string,
+                                                                    object[])
+      IL_0028:  ldloc.1
+      IL_0029:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_002e:  brtrue.s   IL_000b
+
+      IL_0030:  leave.s    IL_0044
+
+    }  
+    finally
+    {
+      IL_0032:  ldloc.1
+      IL_0033:  isinst     [runtime]System.IDisposable
+      IL_0038:  stloc.3
+      IL_0039:  ldloc.3
+      IL_003a:  brfalse.s  IL_0043
+
+      IL_003c:  ldloc.3
+      IL_003d:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0042:  endfinally
+      IL_0043:  endfinally
+    }  
+    IL_0044:  ret
+  } 
+
+  .method public static void  testSimpleForEachArrayLoopWithOneStatement(int32[] inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (int32[] V_0,
+             int32 V_1,
+             int32 V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.1
+    IL_0004:  br.s       IL_0022
+
+    IL_0006:  ldloc.0
+    IL_0007:  ldloc.1
+    IL_0008:  ldelem     [runtime]System.Int32
+    IL_000d:  stloc.2
+    IL_000e:  ldstr      "{0}"
+    IL_0013:  ldloc.2
+    IL_0014:  box        [runtime]System.Int32
+    IL_0019:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_001e:  ldloc.1
+    IL_001f:  ldc.i4.1
+    IL_0020:  add
+    IL_0021:  stloc.1
+    IL_0022:  ldloc.1
+    IL_0023:  ldloc.0
+    IL_0024:  ldlen
+    IL_0025:  conv.i4
+    IL_0026:  blt.s      IL_0006
+
+    IL_0028:  ret
+  } 
+
+  .method public static void  testSimpleForEachArrayLoopWithTwoStatements(int32[] inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (int32[] V_0,
+             int32 V_1,
+             int32 V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.1
+    IL_0004:  br.s       IL_0032
+
+    IL_0006:  ldloc.0
+    IL_0007:  ldloc.1
+    IL_0008:  ldelem     [runtime]System.Int32
+    IL_000d:  stloc.2
+    IL_000e:  ldstr      "{0}"
+    IL_0013:  ldloc.2
+    IL_0014:  box        [runtime]System.Int32
+    IL_0019:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_001e:  ldstr      "{0}"
+    IL_0023:  ldloc.2
+    IL_0024:  box        [runtime]System.Int32
+    IL_0029:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_002e:  ldloc.1
+    IL_002f:  ldc.i4.1
+    IL_0030:  add
+    IL_0031:  stloc.1
+    IL_0032:  ldloc.1
+    IL_0033:  ldloc.0
+    IL_0034:  ldlen
+    IL_0035:  conv.i4
+    IL_0036:  blt.s      IL_0006
+
+    IL_0038:  ret
+  } 
+
+  .method public static void  testSimpleForEachListLoopWithOneStatement(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0008:  stloc.1
+    IL_0009:  br.s       IL_002b
+
+    IL_000b:  ldloc.0
+    IL_000c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0011:  stloc.2
+    IL_0012:  ldstr      "{0}"
+    IL_0017:  ldloc.2
+    IL_0018:  box        [runtime]System.Int32
+    IL_001d:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0022:  ldloc.1
+    IL_0023:  stloc.0
+    IL_0024:  ldloc.0
+    IL_0025:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_002a:  stloc.1
+    IL_002b:  ldloc.1
+    IL_002c:  brtrue.s   IL_000b
+
+    IL_002e:  ret
+  } 
+
+  .method public static void  testSimpleForEachListLoopWithTwoStatements(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0008:  stloc.1
+    IL_0009:  br.s       IL_003b
+
+    IL_000b:  ldloc.0
+    IL_000c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0011:  stloc.2
+    IL_0012:  ldstr      "{0}"
+    IL_0017:  ldloc.2
+    IL_0018:  box        [runtime]System.Int32
+    IL_001d:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0022:  ldstr      "{0}"
+    IL_0027:  ldloc.2
+    IL_0028:  box        [runtime]System.Int32
+    IL_002d:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0032:  ldloc.1
+    IL_0033:  stloc.0
+    IL_0034:  ldloc.0
+    IL_0035:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_003a:  stloc.1
+    IL_003b:  ldloc.1
+    IL_003c:  brtrue.s   IL_000b
+
+    IL_003e:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntRangeLoopWithOneStatement(int32 start,
+                                                                            int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0022
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0018:  ldloc.1
+    IL_0019:  ldc.i4.1
+    IL_001a:  add
+    IL_001b:  stloc.1
+    IL_001c:  ldloc.1
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.1
+    IL_001f:  add
+    IL_0020:  bne.un.s   IL_0008
+
+    IL_0022:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntRangeLoopWithTwoStatements(int32 start,
+                                                                             int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0032
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0018:  ldstr      "{0}"
+    IL_001d:  ldloc.1
+    IL_001e:  box        [runtime]System.Int32
+    IL_0023:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0028:  ldloc.1
+    IL_0029:  ldc.i4.1
+    IL_002a:  add
+    IL_002b:  stloc.1
+    IL_002c:  ldloc.1
+    IL_002d:  ldloc.0
+    IL_002e:  ldc.i4.1
+    IL_002f:  add
+    IL_0030:  bne.un.s   IL_0008
+
+    IL_0032:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntRangeLoopDownWithOneStatement(int32 start,
+                                                                                int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_1,
+             int32 V_2,
+             class [runtime]System.IDisposable V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  ldc.i4.m1
+    IL_0002:  ldarg.1
+    IL_0003:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                     int32,
+                                                                                                                                                                     int32)
+    IL_0008:  stloc.0
+    IL_0009:  ldloc.0
+    IL_000a:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_000f:  stloc.1
+    .try
+    {
+      IL_0010:  br.s       IL_0029
+
+      IL_0012:  ldloc.1
+      IL_0013:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0018:  stloc.2
+      IL_0019:  ldstr      "{0}"
+      IL_001e:  ldloc.2
+      IL_001f:  box        [runtime]System.Int32
+      IL_0024:  call       void [runtime]System.Console::WriteLine(string,
+                                                                    object)
+      IL_0029:  ldloc.1
+      IL_002a:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_002f:  brtrue.s   IL_0012
+
+      IL_0031:  leave.s    IL_0045
+
+    }  
+    finally
+    {
+      IL_0033:  ldloc.1
+      IL_0034:  isinst     [runtime]System.IDisposable
+      IL_0039:  stloc.3
+      IL_003a:  ldloc.3
+      IL_003b:  brfalse.s  IL_0044
+
+      IL_003d:  ldloc.3
+      IL_003e:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0043:  endfinally
+      IL_0044:  endfinally
+    }  
+    IL_0045:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntRangeLoopDownWithTwoStatements(int32 start,
+                                                                                 int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_1,
+             int32 V_2,
+             class [runtime]System.IDisposable V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  ldc.i4.m1
+    IL_0002:  ldarg.1
+    IL_0003:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                     int32,
+                                                                                                                                                                     int32)
+    IL_0008:  stloc.0
+    IL_0009:  ldloc.0
+    IL_000a:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_000f:  stloc.1
+    .try
+    {
+      IL_0010:  br.s       IL_0039
+
+      IL_0012:  ldloc.1
+      IL_0013:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0018:  stloc.2
+      IL_0019:  ldstr      "{0}"
+      IL_001e:  ldloc.2
+      IL_001f:  box        [runtime]System.Int32
+      IL_0024:  call       void [runtime]System.Console::WriteLine(string,
+                                                                    object)
+      IL_0029:  ldstr      "{0}"
+      IL_002e:  ldloc.2
+      IL_002f:  box        [runtime]System.Int32
+      IL_0034:  call       void [runtime]System.Console::WriteLine(string,
+                                                                    object)
+      IL_0039:  ldloc.1
+      IL_003a:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_003f:  brtrue.s   IL_0012
+
+      IL_0041:  leave.s    IL_0055
+
+    }  
+    finally
+    {
+      IL_0043:  ldloc.1
+      IL_0044:  isinst     [runtime]System.IDisposable
+      IL_0049:  stloc.3
+      IL_004a:  ldloc.3
+      IL_004b:  brfalse.s  IL_0054
+
+      IL_004d:  ldloc.3
+      IL_004e:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0053:  endfinally
+      IL_0054:  endfinally
+    }  
+    IL_0055:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntLoopWithOneStatement(int32 start,
+                                                                       int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0022
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0018:  ldloc.1
+    IL_0019:  ldc.i4.1
+    IL_001a:  add
+    IL_001b:  stloc.1
+    IL_001c:  ldloc.1
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.1
+    IL_001f:  add
+    IL_0020:  bne.un.s   IL_0008
+
+    IL_0022:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntLoopWithTwoStatements(int32 start,
+                                                                        int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0032
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0018:  ldstr      "{0}"
+    IL_001d:  ldloc.1
+    IL_001e:  box        [runtime]System.Int32
+    IL_0023:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0028:  ldloc.1
+    IL_0029:  ldc.i4.1
+    IL_002a:  add
+    IL_002b:  stloc.1
+    IL_002c:  ldloc.1
+    IL_002d:  ldloc.0
+    IL_002e:  ldc.i4.1
+    IL_002f:  add
+    IL_0030:  bne.un.s   IL_0008
+
+    IL_0032:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntLoopDownWithOneStatement(int32 start,
+                                                                           int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.1
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.0
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  bgt.s      IL_0022
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0018:  ldloc.1
+    IL_0019:  ldc.i4.1
+    IL_001a:  sub
+    IL_001b:  stloc.1
+    IL_001c:  ldloc.1
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.1
+    IL_001f:  sub
+    IL_0020:  bne.un.s   IL_0008
+
+    IL_0022:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntLoopDownWithTwoStatements(int32 start,
+                                                                            int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.1
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.0
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  bgt.s      IL_0032
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0018:  ldstr      "{0}"
+    IL_001d:  ldloc.1
+    IL_001e:  box        [runtime]System.Int32
+    IL_0023:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0028:  ldloc.1
+    IL_0029:  ldc.i4.1
+    IL_002a:  sub
+    IL_002b:  stloc.1
+    IL_002c:  ldloc.1
+    IL_002d:  ldloc.0
+    IL_002e:  ldc.i4.1
+    IL_002f:  sub
+    IL_0030:  bne.un.s   IL_0008
+
+    IL_0032:  ret
+  } 
+
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest7() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_2,
+             int32 V_3,
+             class [runtime]System.IDisposable V_4)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.1
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.4
+    IL_0004:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                     int32,
+                                                                                                                                                                     int32)
+    IL_0009:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_000e:  stloc.1
+    .try
+    {
+      IL_000f:  br.s       IL_0031
+
+      IL_0011:  ldloc.1
+      IL_0012:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0017:  stloc.3
+      IL_0018:  ldstr      "hello"
+      IL_001d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_0022:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0027:  pop
+      IL_0028:  ldloca.s   V_0
+      IL_002a:  ldloc.3
+      IL_002b:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Add(!0)
+      IL_0030:  nop
+      IL_0031:  ldloc.1
+      IL_0032:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0037:  brtrue.s   IL_0011
+
+      IL_0039:  ldnull
+      IL_003a:  stloc.2
+      IL_003b:  leave.s    IL_0052
+
+    }  
+    finally
+    {
+      IL_003d:  ldloc.1
+      IL_003e:  isinst     [runtime]System.IDisposable
+      IL_0043:  stloc.s    V_4
+      IL_0045:  ldloc.s    V_4
+      IL_0047:  brfalse.s  IL_0051
+
+      IL_0049:  ldloc.s    V_4
+      IL_004b:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0050:  endfinally
+      IL_0051:  endfinally
+    }  
+    IL_0052:  ldloc.2
+    IL_0053:  pop
+    IL_0054:  ldloca.s   V_0
+    IL_0056:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Close()
+    IL_005b:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest7::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest7::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [runtime]System.Exception V_2,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 SeqExpressionSteppingTest7::r@4
+    IL_0006:  ldstr      "res = %A"
+    IL_000b:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor(string)
+    IL_0010:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0015:  stloc.0
+    .try
+    {
+      IL_0016:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> SeqExpressionSteppingTest7::f<int32>()
+      IL_001b:  stloc.1
+      IL_001c:  leave.s    IL_004b
+
+    }  
+    catch [runtime]System.Object 
+    {
+      IL_001e:  castclass  [runtime]System.Exception
+      IL_0023:  stloc.2
+      IL_0024:  ldloc.2
+      IL_0025:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> [FSharp.Core]Microsoft.FSharp.Core.Operators::FailurePattern(class [runtime]System.Exception)
+      IL_002a:  stloc.3
+      IL_002b:  ldloc.3
+      IL_002c:  brfalse.s  IL_0040
+
+      IL_002e:  call       int32 SeqExpressionSteppingTest7::get_r()
+      IL_0033:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+      IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_003d:  stloc.1
+      IL_003e:  leave.s    IL_004b
+
+      IL_0040:  rethrow
+      IL_0042:  ldnull
+      IL_0043:  unbox.any  class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+      IL_0048:  stloc.1
+      IL_0049:  leave.s    IL_004b
+
+    }  
+    IL_004b:  ldloc.0
+    IL_004c:  ldloc.1
+    IL_004d:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0052:  pop
+    IL_0053:  ret
+  } 
+
+  .property int32 r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .set void SeqExpressionSteppingTest7::set_r(int32)
+    .get int32 SeqExpressionSteppingTest7::get_r()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$SeqExpressionSteppingTest7
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void SeqExpressionSteppingTest7::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.net472.release.bsl
new file mode 100644
index 00000000000..f0812837c64
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.net472.release.bsl
@@ -0,0 +1,830 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed SeqExpressionSteppingTest7
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly int32 r@4
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32 get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 SeqExpressionSteppingTest7::r@4
+    IL_0005:  ret
+  } 
+
+  .method public specialname static void set_r(int32 'value') cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  stsfld     int32 SeqExpressionSteppingTest7::r@4
+    IL_0006:  ret
+  } 
+
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a> f<a>() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<!!a> V_0,
+             string V_1)
+    IL_0000:  nop
+    IL_0001:  nop
+    IL_0002:  call       int32 SeqExpressionSteppingTest7::get_r()
+    IL_0007:  ldc.i4.1
+    IL_0008:  add
+    IL_0009:  call       void SeqExpressionSteppingTest7::set_r(int32)
+    IL_000e:  ldc.i4.1
+    IL_000f:  brfalse.s  IL_0034
+
+    IL_0011:  ldstr      ""
+    IL_0016:  stloc.1
+    IL_0017:  ldloca.s   V_0
+    IL_0019:  ldc.i4.0
+    IL_001a:  brfalse.s  IL_0024
+
+    IL_001c:  ldnull
+    IL_001d:  unbox.any  class [runtime]System.Collections.Generic.IEnumerable`1<!!a>
+    IL_0022:  br.s       IL_002b
+
+    IL_0024:  ldloc.1
+    IL_0025:  call       class [runtime]System.Exception [FSharp.Core]Microsoft.FSharp.Core.Operators::Failure(string)
+    IL_002a:  throw
+
+    IL_002b:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<!!a>::AddMany(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0030:  nop
+    IL_0031:  nop
+    IL_0032:  br.s       IL_0035
+
+    IL_0034:  nop
+    IL_0035:  ldloca.s   V_0
+    IL_0037:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<!!a>::Close()
+    IL_003c:  ret
+  } 
+
+  .method public static void  testSimpleForEachSeqLoopWithOneStatement(class [runtime]System.Collections.Generic.IEnumerable`1<object[]> inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<object[]> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<object[]> V_1,
+             object[] V_2,
+             class [runtime]System.IDisposable V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<object[]>::GetEnumerator()
+    IL_0008:  stloc.1
+    .try
+    {
+      IL_0009:  br.s       IL_001d
+
+      IL_000b:  ldloc.1
+      IL_000c:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<object[]>::get_Current()
+      IL_0011:  stloc.2
+      IL_0012:  ldstr      "{0}"
+      IL_0017:  ldloc.2
+      IL_0018:  call       void [runtime]System.Console::WriteLine(string,
+                                                                    object[])
+      IL_001d:  ldloc.1
+      IL_001e:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0023:  brtrue.s   IL_000b
+
+      IL_0025:  leave.s    IL_0039
+
+    }  
+    finally
+    {
+      IL_0027:  ldloc.1
+      IL_0028:  isinst     [runtime]System.IDisposable
+      IL_002d:  stloc.3
+      IL_002e:  ldloc.3
+      IL_002f:  brfalse.s  IL_0038
+
+      IL_0031:  ldloc.3
+      IL_0032:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0037:  endfinally
+      IL_0038:  endfinally
+    }  
+    IL_0039:  ret
+  } 
+
+  .method public static void  testSimpleForEachSeqLoopWithTwoStatements(class [runtime]System.Collections.Generic.IEnumerable`1<object[]> inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<object[]> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<object[]> V_1,
+             object[] V_2,
+             class [runtime]System.IDisposable V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<object[]>::GetEnumerator()
+    IL_0008:  stloc.1
+    .try
+    {
+      IL_0009:  br.s       IL_0028
+
+      IL_000b:  ldloc.1
+      IL_000c:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<object[]>::get_Current()
+      IL_0011:  stloc.2
+      IL_0012:  ldstr      "{0}"
+      IL_0017:  ldloc.2
+      IL_0018:  call       void [runtime]System.Console::WriteLine(string,
+                                                                    object[])
+      IL_001d:  ldstr      "{0}"
+      IL_0022:  ldloc.2
+      IL_0023:  call       void [runtime]System.Console::WriteLine(string,
+                                                                    object[])
+      IL_0028:  ldloc.1
+      IL_0029:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_002e:  brtrue.s   IL_000b
+
+      IL_0030:  leave.s    IL_0044
+
+    }  
+    finally
+    {
+      IL_0032:  ldloc.1
+      IL_0033:  isinst     [runtime]System.IDisposable
+      IL_0038:  stloc.3
+      IL_0039:  ldloc.3
+      IL_003a:  brfalse.s  IL_0043
+
+      IL_003c:  ldloc.3
+      IL_003d:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0042:  endfinally
+      IL_0043:  endfinally
+    }  
+    IL_0044:  ret
+  } 
+
+  .method public static void  testSimpleForEachArrayLoopWithOneStatement(int32[] inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (int32[] V_0,
+             int32 V_1,
+             int32 V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.1
+    IL_0004:  br.s       IL_0022
+
+    IL_0006:  ldloc.0
+    IL_0007:  ldloc.1
+    IL_0008:  ldelem     [runtime]System.Int32
+    IL_000d:  stloc.2
+    IL_000e:  ldstr      "{0}"
+    IL_0013:  ldloc.2
+    IL_0014:  box        [runtime]System.Int32
+    IL_0019:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_001e:  ldloc.1
+    IL_001f:  ldc.i4.1
+    IL_0020:  add
+    IL_0021:  stloc.1
+    IL_0022:  ldloc.1
+    IL_0023:  ldloc.0
+    IL_0024:  ldlen
+    IL_0025:  conv.i4
+    IL_0026:  blt.s      IL_0006
+
+    IL_0028:  ret
+  } 
+
+  .method public static void  testSimpleForEachArrayLoopWithTwoStatements(int32[] inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (int32[] V_0,
+             int32 V_1,
+             int32 V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.1
+    IL_0004:  br.s       IL_0032
+
+    IL_0006:  ldloc.0
+    IL_0007:  ldloc.1
+    IL_0008:  ldelem     [runtime]System.Int32
+    IL_000d:  stloc.2
+    IL_000e:  ldstr      "{0}"
+    IL_0013:  ldloc.2
+    IL_0014:  box        [runtime]System.Int32
+    IL_0019:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_001e:  ldstr      "{0}"
+    IL_0023:  ldloc.2
+    IL_0024:  box        [runtime]System.Int32
+    IL_0029:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_002e:  ldloc.1
+    IL_002f:  ldc.i4.1
+    IL_0030:  add
+    IL_0031:  stloc.1
+    IL_0032:  ldloc.1
+    IL_0033:  ldloc.0
+    IL_0034:  ldlen
+    IL_0035:  conv.i4
+    IL_0036:  blt.s      IL_0006
+
+    IL_0038:  ret
+  } 
+
+  .method public static void  testSimpleForEachListLoopWithOneStatement(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0008:  stloc.1
+    IL_0009:  br.s       IL_002b
+
+    IL_000b:  ldloc.0
+    IL_000c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0011:  stloc.2
+    IL_0012:  ldstr      "{0}"
+    IL_0017:  ldloc.2
+    IL_0018:  box        [runtime]System.Int32
+    IL_001d:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0022:  ldloc.1
+    IL_0023:  stloc.0
+    IL_0024:  ldloc.0
+    IL_0025:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_002a:  stloc.1
+    IL_002b:  ldloc.1
+    IL_002c:  brtrue.s   IL_000b
+
+    IL_002e:  ret
+  } 
+
+  .method public static void  testSimpleForEachListLoopWithTwoStatements(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0008:  stloc.1
+    IL_0009:  br.s       IL_003b
+
+    IL_000b:  ldloc.0
+    IL_000c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0011:  stloc.2
+    IL_0012:  ldstr      "{0}"
+    IL_0017:  ldloc.2
+    IL_0018:  box        [runtime]System.Int32
+    IL_001d:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0022:  ldstr      "{0}"
+    IL_0027:  ldloc.2
+    IL_0028:  box        [runtime]System.Int32
+    IL_002d:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0032:  ldloc.1
+    IL_0033:  stloc.0
+    IL_0034:  ldloc.0
+    IL_0035:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_003a:  stloc.1
+    IL_003b:  ldloc.1
+    IL_003c:  brtrue.s   IL_000b
+
+    IL_003e:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntRangeLoopWithOneStatement(int32 start,
+                                                                            int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0022
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0018:  ldloc.1
+    IL_0019:  ldc.i4.1
+    IL_001a:  add
+    IL_001b:  stloc.1
+    IL_001c:  ldloc.1
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.1
+    IL_001f:  add
+    IL_0020:  bne.un.s   IL_0008
+
+    IL_0022:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntRangeLoopWithTwoStatements(int32 start,
+                                                                             int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0032
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0018:  ldstr      "{0}"
+    IL_001d:  ldloc.1
+    IL_001e:  box        [runtime]System.Int32
+    IL_0023:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0028:  ldloc.1
+    IL_0029:  ldc.i4.1
+    IL_002a:  add
+    IL_002b:  stloc.1
+    IL_002c:  ldloc.1
+    IL_002d:  ldloc.0
+    IL_002e:  ldc.i4.1
+    IL_002f:  add
+    IL_0030:  bne.un.s   IL_0008
+
+    IL_0032:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntRangeLoopDownWithOneStatement(int32 start,
+                                                                                int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_1,
+             int32 V_2,
+             class [runtime]System.IDisposable V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  ldc.i4.m1
+    IL_0002:  ldarg.1
+    IL_0003:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                     int32,
+                                                                                                                                                                     int32)
+    IL_0008:  stloc.0
+    IL_0009:  ldloc.0
+    IL_000a:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_000f:  stloc.1
+    .try
+    {
+      IL_0010:  br.s       IL_0029
+
+      IL_0012:  ldloc.1
+      IL_0013:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0018:  stloc.2
+      IL_0019:  ldstr      "{0}"
+      IL_001e:  ldloc.2
+      IL_001f:  box        [runtime]System.Int32
+      IL_0024:  call       void [runtime]System.Console::WriteLine(string,
+                                                                    object)
+      IL_0029:  ldloc.1
+      IL_002a:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_002f:  brtrue.s   IL_0012
+
+      IL_0031:  leave.s    IL_0045
+
+    }  
+    finally
+    {
+      IL_0033:  ldloc.1
+      IL_0034:  isinst     [runtime]System.IDisposable
+      IL_0039:  stloc.3
+      IL_003a:  ldloc.3
+      IL_003b:  brfalse.s  IL_0044
+
+      IL_003d:  ldloc.3
+      IL_003e:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0043:  endfinally
+      IL_0044:  endfinally
+    }  
+    IL_0045:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntRangeLoopDownWithTwoStatements(int32 start,
+                                                                                 int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_1,
+             int32 V_2,
+             class [runtime]System.IDisposable V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  ldc.i4.m1
+    IL_0002:  ldarg.1
+    IL_0003:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                     int32,
+                                                                                                                                                                     int32)
+    IL_0008:  stloc.0
+    IL_0009:  ldloc.0
+    IL_000a:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_000f:  stloc.1
+    .try
+    {
+      IL_0010:  br.s       IL_0039
+
+      IL_0012:  ldloc.1
+      IL_0013:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0018:  stloc.2
+      IL_0019:  ldstr      "{0}"
+      IL_001e:  ldloc.2
+      IL_001f:  box        [runtime]System.Int32
+      IL_0024:  call       void [runtime]System.Console::WriteLine(string,
+                                                                    object)
+      IL_0029:  ldstr      "{0}"
+      IL_002e:  ldloc.2
+      IL_002f:  box        [runtime]System.Int32
+      IL_0034:  call       void [runtime]System.Console::WriteLine(string,
+                                                                    object)
+      IL_0039:  ldloc.1
+      IL_003a:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_003f:  brtrue.s   IL_0012
+
+      IL_0041:  leave.s    IL_0055
+
+    }  
+    finally
+    {
+      IL_0043:  ldloc.1
+      IL_0044:  isinst     [runtime]System.IDisposable
+      IL_0049:  stloc.3
+      IL_004a:  ldloc.3
+      IL_004b:  brfalse.s  IL_0054
+
+      IL_004d:  ldloc.3
+      IL_004e:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0053:  endfinally
+      IL_0054:  endfinally
+    }  
+    IL_0055:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntLoopWithOneStatement(int32 start,
+                                                                       int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0022
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0018:  ldloc.1
+    IL_0019:  ldc.i4.1
+    IL_001a:  add
+    IL_001b:  stloc.1
+    IL_001c:  ldloc.1
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.1
+    IL_001f:  add
+    IL_0020:  bne.un.s   IL_0008
+
+    IL_0022:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntLoopWithTwoStatements(int32 start,
+                                                                        int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0032
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0018:  ldstr      "{0}"
+    IL_001d:  ldloc.1
+    IL_001e:  box        [runtime]System.Int32
+    IL_0023:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0028:  ldloc.1
+    IL_0029:  ldc.i4.1
+    IL_002a:  add
+    IL_002b:  stloc.1
+    IL_002c:  ldloc.1
+    IL_002d:  ldloc.0
+    IL_002e:  ldc.i4.1
+    IL_002f:  add
+    IL_0030:  bne.un.s   IL_0008
+
+    IL_0032:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntLoopDownWithOneStatement(int32 start,
+                                                                           int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.1
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.0
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  bgt.s      IL_0022
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0018:  ldloc.1
+    IL_0019:  ldc.i4.1
+    IL_001a:  sub
+    IL_001b:  stloc.1
+    IL_001c:  ldloc.1
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.1
+    IL_001f:  sub
+    IL_0020:  bne.un.s   IL_0008
+
+    IL_0022:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntLoopDownWithTwoStatements(int32 start,
+                                                                            int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.1
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.0
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  bgt.s      IL_0032
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0018:  ldstr      "{0}"
+    IL_001d:  ldloc.1
+    IL_001e:  box        [runtime]System.Int32
+    IL_0023:  call       void [runtime]System.Console::WriteLine(string,
+                                                                  object)
+    IL_0028:  ldloc.1
+    IL_0029:  ldc.i4.1
+    IL_002a:  sub
+    IL_002b:  stloc.1
+    IL_002c:  ldloc.1
+    IL_002d:  ldloc.0
+    IL_002e:  ldc.i4.1
+    IL_002f:  sub
+    IL_0030:  bne.un.s   IL_0008
+
+    IL_0032:  ret
+  } 
+
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest7() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_2,
+             int32 V_3,
+             class [runtime]System.IDisposable V_4)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.1
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.4
+    IL_0004:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                     int32,
+                                                                                                                                                                     int32)
+    IL_0009:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_000e:  stloc.1
+    .try
+    {
+      IL_000f:  br.s       IL_0031
+
+      IL_0011:  ldloc.1
+      IL_0012:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0017:  stloc.3
+      IL_0018:  ldstr      "hello"
+      IL_001d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_0022:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0027:  pop
+      IL_0028:  ldloca.s   V_0
+      IL_002a:  ldloc.3
+      IL_002b:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Add(!0)
+      IL_0030:  nop
+      IL_0031:  ldloc.1
+      IL_0032:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0037:  brtrue.s   IL_0011
+
+      IL_0039:  ldnull
+      IL_003a:  stloc.2
+      IL_003b:  leave.s    IL_0052
+
+    }  
+    finally
+    {
+      IL_003d:  ldloc.1
+      IL_003e:  isinst     [runtime]System.IDisposable
+      IL_0043:  stloc.s    V_4
+      IL_0045:  ldloc.s    V_4
+      IL_0047:  brfalse.s  IL_0051
+
+      IL_0049:  ldloc.s    V_4
+      IL_004b:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0050:  endfinally
+      IL_0051:  endfinally
+    }  
+    IL_0052:  ldloc.2
+    IL_0053:  pop
+    IL_0054:  ldloca.s   V_0
+    IL_0056:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Close()
+    IL_005b:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest7::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest7::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [runtime]System.Exception V_2,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 SeqExpressionSteppingTest7::r@4
+    IL_0006:  ldstr      "res = %A"
+    IL_000b:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor(string)
+    IL_0010:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0015:  stloc.0
+    .try
+    {
+      IL_0016:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> SeqExpressionSteppingTest7::f<int32>()
+      IL_001b:  stloc.1
+      IL_001c:  leave.s    IL_004b
+
+    }  
+    catch [runtime]System.Object 
+    {
+      IL_001e:  castclass  [runtime]System.Exception
+      IL_0023:  stloc.2
+      IL_0024:  ldloc.2
+      IL_0025:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> [FSharp.Core]Microsoft.FSharp.Core.Operators::FailurePattern(class [runtime]System.Exception)
+      IL_002a:  stloc.3
+      IL_002b:  ldloc.3
+      IL_002c:  brfalse.s  IL_0040
+
+      IL_002e:  call       int32 SeqExpressionSteppingTest7::get_r()
+      IL_0033:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+      IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_003d:  stloc.1
+      IL_003e:  leave.s    IL_004b
+
+      IL_0040:  rethrow
+      IL_0042:  ldnull
+      IL_0043:  unbox.any  class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+      IL_0048:  stloc.1
+      IL_0049:  leave.s    IL_004b
+
+    }  
+    IL_004b:  ldloc.0
+    IL_004c:  ldloc.1
+    IL_004d:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0052:  pop
+    IL_0053:  ret
+  } 
+
+  .property int32 r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .set void SeqExpressionSteppingTest7::set_r(int32)
+    .get int32 SeqExpressionSteppingTest7::get_r()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$SeqExpressionSteppingTest7
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void SeqExpressionSteppingTest7::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.netcore.debug.bsl
new file mode 100644
index 00000000000..e3eea368d57
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.netcore.debug.bsl
@@ -0,0 +1,831 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern runtime { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed SeqExpressionSteppingTest7
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly int32 r@4
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32 get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 SeqExpressionSteppingTest7::r@4
+    IL_0005:  ret
+  } 
+
+  .method public specialname static void set_r(int32 'value') cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  stsfld     int32 SeqExpressionSteppingTest7::r@4
+    IL_0006:  ret
+  } 
+
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a> f<a>() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<!!a> V_0,
+             string V_1)
+    IL_0000:  nop
+    IL_0001:  nop
+    IL_0002:  call       int32 SeqExpressionSteppingTest7::get_r()
+    IL_0007:  ldc.i4.1
+    IL_0008:  add
+    IL_0009:  call       void SeqExpressionSteppingTest7::set_r(int32)
+    IL_000e:  ldc.i4.1
+    IL_000f:  brfalse.s  IL_0034
+
+    IL_0011:  ldstr      ""
+    IL_0016:  stloc.1
+    IL_0017:  ldloca.s   V_0
+    IL_0019:  ldc.i4.0
+    IL_001a:  brfalse.s  IL_0024
+
+    IL_001c:  ldnull
+    IL_001d:  unbox.any  class [runtime]System.Collections.Generic.IEnumerable`1<!!a>
+    IL_0022:  br.s       IL_002b
+
+    IL_0024:  ldloc.1
+    IL_0025:  call       class [runtime]System.Exception [FSharp.Core]Microsoft.FSharp.Core.Operators::Failure(string)
+    IL_002a:  throw
+
+    IL_002b:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<!!a>::AddMany(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0030:  nop
+    IL_0031:  nop
+    IL_0032:  br.s       IL_0035
+
+    IL_0034:  nop
+    IL_0035:  ldloca.s   V_0
+    IL_0037:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<!!a>::Close()
+    IL_003c:  ret
+  } 
+
+  .method public static void  testSimpleForEachSeqLoopWithOneStatement(class [runtime]System.Collections.Generic.IEnumerable`1<object[]> inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<object[]> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<object[]> V_1,
+             object[] V_2,
+             class [runtime]System.IDisposable V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<object[]>::GetEnumerator()
+    IL_0008:  stloc.1
+    .try
+    {
+      IL_0009:  br.s       IL_001d
+
+      IL_000b:  ldloc.1
+      IL_000c:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<object[]>::get_Current()
+      IL_0011:  stloc.2
+      IL_0012:  ldstr      "{0}"
+      IL_0017:  ldloc.2
+      IL_0018:  call       void [runtime]System.Console::WriteLine(string,
+                                                                          object[])
+      IL_001d:  ldloc.1
+      IL_001e:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0023:  brtrue.s   IL_000b
+
+      IL_0025:  leave.s    IL_0039
+
+    }  
+    finally
+    {
+      IL_0027:  ldloc.1
+      IL_0028:  isinst     [runtime]System.IDisposable
+      IL_002d:  stloc.3
+      IL_002e:  ldloc.3
+      IL_002f:  brfalse.s  IL_0038
+
+      IL_0031:  ldloc.3
+      IL_0032:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0037:  endfinally
+      IL_0038:  endfinally
+    }  
+    IL_0039:  ret
+  } 
+
+  .method public static void  testSimpleForEachSeqLoopWithTwoStatements(class [runtime]System.Collections.Generic.IEnumerable`1<object[]> inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<object[]> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<object[]> V_1,
+             object[] V_2,
+             class [runtime]System.IDisposable V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<object[]>::GetEnumerator()
+    IL_0008:  stloc.1
+    .try
+    {
+      IL_0009:  br.s       IL_0028
+
+      IL_000b:  ldloc.1
+      IL_000c:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<object[]>::get_Current()
+      IL_0011:  stloc.2
+      IL_0012:  ldstr      "{0}"
+      IL_0017:  ldloc.2
+      IL_0018:  call       void [runtime]System.Console::WriteLine(string,
+                                                                          object[])
+      IL_001d:  ldstr      "{0}"
+      IL_0022:  ldloc.2
+      IL_0023:  call       void [runtime]System.Console::WriteLine(string,
+                                                                          object[])
+      IL_0028:  ldloc.1
+      IL_0029:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_002e:  brtrue.s   IL_000b
+
+      IL_0030:  leave.s    IL_0044
+
+    }  
+    finally
+    {
+      IL_0032:  ldloc.1
+      IL_0033:  isinst     [runtime]System.IDisposable
+      IL_0038:  stloc.3
+      IL_0039:  ldloc.3
+      IL_003a:  brfalse.s  IL_0043
+
+      IL_003c:  ldloc.3
+      IL_003d:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0042:  endfinally
+      IL_0043:  endfinally
+    }  
+    IL_0044:  ret
+  } 
+
+  .method public static void  testSimpleForEachArrayLoopWithOneStatement(int32[] inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (int32[] V_0,
+             int32 V_1,
+             int32 V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.1
+    IL_0004:  br.s       IL_0022
+
+    IL_0006:  ldloc.0
+    IL_0007:  ldloc.1
+    IL_0008:  ldelem     [runtime]System.Int32
+    IL_000d:  stloc.2
+    IL_000e:  ldstr      "{0}"
+    IL_0013:  ldloc.2
+    IL_0014:  box        [runtime]System.Int32
+    IL_0019:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_001e:  ldloc.1
+    IL_001f:  ldc.i4.1
+    IL_0020:  add
+    IL_0021:  stloc.1
+    IL_0022:  ldloc.1
+    IL_0023:  ldloc.0
+    IL_0024:  ldlen
+    IL_0025:  conv.i4
+    IL_0026:  blt.s      IL_0006
+
+    IL_0028:  ret
+  } 
+
+  .method public static void  testSimpleForEachArrayLoopWithTwoStatements(int32[] inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (int32[] V_0,
+             int32 V_1,
+             int32 V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.1
+    IL_0004:  br.s       IL_0032
+
+    IL_0006:  ldloc.0
+    IL_0007:  ldloc.1
+    IL_0008:  ldelem     [runtime]System.Int32
+    IL_000d:  stloc.2
+    IL_000e:  ldstr      "{0}"
+    IL_0013:  ldloc.2
+    IL_0014:  box        [runtime]System.Int32
+    IL_0019:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_001e:  ldstr      "{0}"
+    IL_0023:  ldloc.2
+    IL_0024:  box        [runtime]System.Int32
+    IL_0029:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_002e:  ldloc.1
+    IL_002f:  ldc.i4.1
+    IL_0030:  add
+    IL_0031:  stloc.1
+    IL_0032:  ldloc.1
+    IL_0033:  ldloc.0
+    IL_0034:  ldlen
+    IL_0035:  conv.i4
+    IL_0036:  blt.s      IL_0006
+
+    IL_0038:  ret
+  } 
+
+  .method public static void  testSimpleForEachListLoopWithOneStatement(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0008:  stloc.1
+    IL_0009:  br.s       IL_002b
+
+    IL_000b:  ldloc.0
+    IL_000c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0011:  stloc.2
+    IL_0012:  ldstr      "{0}"
+    IL_0017:  ldloc.2
+    IL_0018:  box        [runtime]System.Int32
+    IL_001d:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0022:  ldloc.1
+    IL_0023:  stloc.0
+    IL_0024:  ldloc.0
+    IL_0025:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_002a:  stloc.1
+    IL_002b:  ldloc.1
+    IL_002c:  brtrue.s   IL_000b
+
+    IL_002e:  ret
+  } 
+
+  .method public static void  testSimpleForEachListLoopWithTwoStatements(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0008:  stloc.1
+    IL_0009:  br.s       IL_003b
+
+    IL_000b:  ldloc.0
+    IL_000c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0011:  stloc.2
+    IL_0012:  ldstr      "{0}"
+    IL_0017:  ldloc.2
+    IL_0018:  box        [runtime]System.Int32
+    IL_001d:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0022:  ldstr      "{0}"
+    IL_0027:  ldloc.2
+    IL_0028:  box        [runtime]System.Int32
+    IL_002d:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0032:  ldloc.1
+    IL_0033:  stloc.0
+    IL_0034:  ldloc.0
+    IL_0035:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_003a:  stloc.1
+    IL_003b:  ldloc.1
+    IL_003c:  brtrue.s   IL_000b
+
+    IL_003e:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntRangeLoopWithOneStatement(int32 start,
+                                                                            int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0022
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0018:  ldloc.1
+    IL_0019:  ldc.i4.1
+    IL_001a:  add
+    IL_001b:  stloc.1
+    IL_001c:  ldloc.1
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.1
+    IL_001f:  add
+    IL_0020:  bne.un.s   IL_0008
+
+    IL_0022:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntRangeLoopWithTwoStatements(int32 start,
+                                                                             int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0032
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0018:  ldstr      "{0}"
+    IL_001d:  ldloc.1
+    IL_001e:  box        [runtime]System.Int32
+    IL_0023:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0028:  ldloc.1
+    IL_0029:  ldc.i4.1
+    IL_002a:  add
+    IL_002b:  stloc.1
+    IL_002c:  ldloc.1
+    IL_002d:  ldloc.0
+    IL_002e:  ldc.i4.1
+    IL_002f:  add
+    IL_0030:  bne.un.s   IL_0008
+
+    IL_0032:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntRangeLoopDownWithOneStatement(int32 start,
+                                                                                int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_1,
+             int32 V_2,
+             class [runtime]System.IDisposable V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  ldc.i4.m1
+    IL_0002:  ldarg.1
+    IL_0003:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                           int32,
+                                                                                                                                                                           int32)
+    IL_0008:  stloc.0
+    IL_0009:  ldloc.0
+    IL_000a:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_000f:  stloc.1
+    .try
+    {
+      IL_0010:  br.s       IL_0029
+
+      IL_0012:  ldloc.1
+      IL_0013:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0018:  stloc.2
+      IL_0019:  ldstr      "{0}"
+      IL_001e:  ldloc.2
+      IL_001f:  box        [runtime]System.Int32
+      IL_0024:  call       void [runtime]System.Console::WriteLine(string,
+                                                                          object)
+      IL_0029:  ldloc.1
+      IL_002a:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_002f:  brtrue.s   IL_0012
+
+      IL_0031:  leave.s    IL_0045
+
+    }  
+    finally
+    {
+      IL_0033:  ldloc.1
+      IL_0034:  isinst     [runtime]System.IDisposable
+      IL_0039:  stloc.3
+      IL_003a:  ldloc.3
+      IL_003b:  brfalse.s  IL_0044
+
+      IL_003d:  ldloc.3
+      IL_003e:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0043:  endfinally
+      IL_0044:  endfinally
+    }  
+    IL_0045:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntRangeLoopDownWithTwoStatements(int32 start,
+                                                                                 int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_1,
+             int32 V_2,
+             class [runtime]System.IDisposable V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  ldc.i4.m1
+    IL_0002:  ldarg.1
+    IL_0003:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                           int32,
+                                                                                                                                                                           int32)
+    IL_0008:  stloc.0
+    IL_0009:  ldloc.0
+    IL_000a:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_000f:  stloc.1
+    .try
+    {
+      IL_0010:  br.s       IL_0039
+
+      IL_0012:  ldloc.1
+      IL_0013:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0018:  stloc.2
+      IL_0019:  ldstr      "{0}"
+      IL_001e:  ldloc.2
+      IL_001f:  box        [runtime]System.Int32
+      IL_0024:  call       void [runtime]System.Console::WriteLine(string,
+                                                                          object)
+      IL_0029:  ldstr      "{0}"
+      IL_002e:  ldloc.2
+      IL_002f:  box        [runtime]System.Int32
+      IL_0034:  call       void [runtime]System.Console::WriteLine(string,
+                                                                          object)
+      IL_0039:  ldloc.1
+      IL_003a:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_003f:  brtrue.s   IL_0012
+
+      IL_0041:  leave.s    IL_0055
+
+    }  
+    finally
+    {
+      IL_0043:  ldloc.1
+      IL_0044:  isinst     [runtime]System.IDisposable
+      IL_0049:  stloc.3
+      IL_004a:  ldloc.3
+      IL_004b:  brfalse.s  IL_0054
+
+      IL_004d:  ldloc.3
+      IL_004e:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0053:  endfinally
+      IL_0054:  endfinally
+    }  
+    IL_0055:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntLoopWithOneStatement(int32 start,
+                                                                       int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0022
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0018:  ldloc.1
+    IL_0019:  ldc.i4.1
+    IL_001a:  add
+    IL_001b:  stloc.1
+    IL_001c:  ldloc.1
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.1
+    IL_001f:  add
+    IL_0020:  bne.un.s   IL_0008
+
+    IL_0022:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntLoopWithTwoStatements(int32 start,
+                                                                        int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0032
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0018:  ldstr      "{0}"
+    IL_001d:  ldloc.1
+    IL_001e:  box        [runtime]System.Int32
+    IL_0023:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0028:  ldloc.1
+    IL_0029:  ldc.i4.1
+    IL_002a:  add
+    IL_002b:  stloc.1
+    IL_002c:  ldloc.1
+    IL_002d:  ldloc.0
+    IL_002e:  ldc.i4.1
+    IL_002f:  add
+    IL_0030:  bne.un.s   IL_0008
+
+    IL_0032:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntLoopDownWithOneStatement(int32 start,
+                                                                           int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.1
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.0
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  bgt.s      IL_0022
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0018:  ldloc.1
+    IL_0019:  ldc.i4.1
+    IL_001a:  sub
+    IL_001b:  stloc.1
+    IL_001c:  ldloc.1
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.1
+    IL_001f:  sub
+    IL_0020:  bne.un.s   IL_0008
+
+    IL_0022:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntLoopDownWithTwoStatements(int32 start,
+                                                                            int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.1
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.0
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  bgt.s      IL_0032
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0018:  ldstr      "{0}"
+    IL_001d:  ldloc.1
+    IL_001e:  box        [runtime]System.Int32
+    IL_0023:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0028:  ldloc.1
+    IL_0029:  ldc.i4.1
+    IL_002a:  sub
+    IL_002b:  stloc.1
+    IL_002c:  ldloc.1
+    IL_002d:  ldloc.0
+    IL_002e:  ldc.i4.1
+    IL_002f:  sub
+    IL_0030:  bne.un.s   IL_0008
+
+    IL_0032:  ret
+  } 
+
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest7() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_2,
+             int32 V_3,
+             class [runtime]System.IDisposable V_4)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.1
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.4
+    IL_0004:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                           int32,
+                                                                                                                                                                           int32)
+    IL_0009:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_000e:  stloc.1
+    .try
+    {
+      IL_000f:  br.s       IL_0031
+
+      IL_0011:  ldloc.1
+      IL_0012:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0017:  stloc.3
+      IL_0018:  ldstr      "hello"
+      IL_001d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_0022:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0027:  pop
+      IL_0028:  ldloca.s   V_0
+      IL_002a:  ldloc.3
+      IL_002b:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Add(!0)
+      IL_0030:  nop
+      IL_0031:  ldloc.1
+      IL_0032:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0037:  brtrue.s   IL_0011
+
+      IL_0039:  ldnull
+      IL_003a:  stloc.2
+      IL_003b:  leave.s    IL_0052
+
+    }  
+    finally
+    {
+      IL_003d:  ldloc.1
+      IL_003e:  isinst     [runtime]System.IDisposable
+      IL_0043:  stloc.s    V_4
+      IL_0045:  ldloc.s    V_4
+      IL_0047:  brfalse.s  IL_0051
+
+      IL_0049:  ldloc.s    V_4
+      IL_004b:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0050:  endfinally
+      IL_0051:  endfinally
+    }  
+    IL_0052:  ldloc.2
+    IL_0053:  pop
+    IL_0054:  ldloca.s   V_0
+    IL_0056:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Close()
+    IL_005b:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest7::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest7::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [runtime]System.Exception V_2,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 SeqExpressionSteppingTest7::r@4
+    IL_0006:  ldstr      "res = %A"
+    IL_000b:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor(string)
+    IL_0010:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0015:  stloc.0
+    .try
+    {
+      IL_0016:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> SeqExpressionSteppingTest7::f<int32>()
+      IL_001b:  stloc.1
+      IL_001c:  leave.s    IL_004b
+
+    }  
+    catch [runtime]System.Object 
+    {
+      IL_001e:  castclass  [runtime]System.Exception
+      IL_0023:  stloc.2
+      IL_0024:  ldloc.2
+      IL_0025:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> [FSharp.Core]Microsoft.FSharp.Core.Operators::FailurePattern(class [runtime]System.Exception)
+      IL_002a:  stloc.3
+      IL_002b:  ldloc.3
+      IL_002c:  brfalse.s  IL_0040
+
+      IL_002e:  call       int32 SeqExpressionSteppingTest7::get_r()
+      IL_0033:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+      IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_003d:  stloc.1
+      IL_003e:  leave.s    IL_004b
+
+      IL_0040:  rethrow
+      IL_0042:  ldnull
+      IL_0043:  unbox.any  class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+      IL_0048:  stloc.1
+      IL_0049:  leave.s    IL_004b
+
+    }  
+    IL_004b:  ldloc.0
+    IL_004c:  ldloc.1
+    IL_004d:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0052:  pop
+    IL_0053:  ret
+  } 
+
+  .property int32 r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .set void SeqExpressionSteppingTest7::set_r(int32)
+    .get int32 SeqExpressionSteppingTest7::get_r()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$SeqExpressionSteppingTest7
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void SeqExpressionSteppingTest7::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.netcore.release.bsl
new file mode 100644
index 00000000000..e3eea368d57
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionStepping/SeqExpressionSteppingTest07.fs.RealInternalSignatureOn.il.netcore.release.bsl
@@ -0,0 +1,831 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern runtime { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed SeqExpressionSteppingTest7
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .field static assembly int32 r@4
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static int32 get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     int32 SeqExpressionSteppingTest7::r@4
+    IL_0005:  ret
+  } 
+
+  .method public specialname static void set_r(int32 'value') cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  stsfld     int32 SeqExpressionSteppingTest7::r@4
+    IL_0006:  ret
+  } 
+
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!a> f<a>() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<!!a> V_0,
+             string V_1)
+    IL_0000:  nop
+    IL_0001:  nop
+    IL_0002:  call       int32 SeqExpressionSteppingTest7::get_r()
+    IL_0007:  ldc.i4.1
+    IL_0008:  add
+    IL_0009:  call       void SeqExpressionSteppingTest7::set_r(int32)
+    IL_000e:  ldc.i4.1
+    IL_000f:  brfalse.s  IL_0034
+
+    IL_0011:  ldstr      ""
+    IL_0016:  stloc.1
+    IL_0017:  ldloca.s   V_0
+    IL_0019:  ldc.i4.0
+    IL_001a:  brfalse.s  IL_0024
+
+    IL_001c:  ldnull
+    IL_001d:  unbox.any  class [runtime]System.Collections.Generic.IEnumerable`1<!!a>
+    IL_0022:  br.s       IL_002b
+
+    IL_0024:  ldloc.1
+    IL_0025:  call       class [runtime]System.Exception [FSharp.Core]Microsoft.FSharp.Core.Operators::Failure(string)
+    IL_002a:  throw
+
+    IL_002b:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<!!a>::AddMany(class [runtime]System.Collections.Generic.IEnumerable`1<!0>)
+    IL_0030:  nop
+    IL_0031:  nop
+    IL_0032:  br.s       IL_0035
+
+    IL_0034:  nop
+    IL_0035:  ldloca.s   V_0
+    IL_0037:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<!!a>::Close()
+    IL_003c:  ret
+  } 
+
+  .method public static void  testSimpleForEachSeqLoopWithOneStatement(class [runtime]System.Collections.Generic.IEnumerable`1<object[]> inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<object[]> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<object[]> V_1,
+             object[] V_2,
+             class [runtime]System.IDisposable V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<object[]>::GetEnumerator()
+    IL_0008:  stloc.1
+    .try
+    {
+      IL_0009:  br.s       IL_001d
+
+      IL_000b:  ldloc.1
+      IL_000c:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<object[]>::get_Current()
+      IL_0011:  stloc.2
+      IL_0012:  ldstr      "{0}"
+      IL_0017:  ldloc.2
+      IL_0018:  call       void [runtime]System.Console::WriteLine(string,
+                                                                          object[])
+      IL_001d:  ldloc.1
+      IL_001e:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0023:  brtrue.s   IL_000b
+
+      IL_0025:  leave.s    IL_0039
+
+    }  
+    finally
+    {
+      IL_0027:  ldloc.1
+      IL_0028:  isinst     [runtime]System.IDisposable
+      IL_002d:  stloc.3
+      IL_002e:  ldloc.3
+      IL_002f:  brfalse.s  IL_0038
+
+      IL_0031:  ldloc.3
+      IL_0032:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0037:  endfinally
+      IL_0038:  endfinally
+    }  
+    IL_0039:  ret
+  } 
+
+  .method public static void  testSimpleForEachSeqLoopWithTwoStatements(class [runtime]System.Collections.Generic.IEnumerable`1<object[]> inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<object[]> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<object[]> V_1,
+             object[] V_2,
+             class [runtime]System.IDisposable V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<object[]>::GetEnumerator()
+    IL_0008:  stloc.1
+    .try
+    {
+      IL_0009:  br.s       IL_0028
+
+      IL_000b:  ldloc.1
+      IL_000c:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<object[]>::get_Current()
+      IL_0011:  stloc.2
+      IL_0012:  ldstr      "{0}"
+      IL_0017:  ldloc.2
+      IL_0018:  call       void [runtime]System.Console::WriteLine(string,
+                                                                          object[])
+      IL_001d:  ldstr      "{0}"
+      IL_0022:  ldloc.2
+      IL_0023:  call       void [runtime]System.Console::WriteLine(string,
+                                                                          object[])
+      IL_0028:  ldloc.1
+      IL_0029:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_002e:  brtrue.s   IL_000b
+
+      IL_0030:  leave.s    IL_0044
+
+    }  
+    finally
+    {
+      IL_0032:  ldloc.1
+      IL_0033:  isinst     [runtime]System.IDisposable
+      IL_0038:  stloc.3
+      IL_0039:  ldloc.3
+      IL_003a:  brfalse.s  IL_0043
+
+      IL_003c:  ldloc.3
+      IL_003d:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0042:  endfinally
+      IL_0043:  endfinally
+    }  
+    IL_0044:  ret
+  } 
+
+  .method public static void  testSimpleForEachArrayLoopWithOneStatement(int32[] inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (int32[] V_0,
+             int32 V_1,
+             int32 V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.1
+    IL_0004:  br.s       IL_0022
+
+    IL_0006:  ldloc.0
+    IL_0007:  ldloc.1
+    IL_0008:  ldelem     [runtime]System.Int32
+    IL_000d:  stloc.2
+    IL_000e:  ldstr      "{0}"
+    IL_0013:  ldloc.2
+    IL_0014:  box        [runtime]System.Int32
+    IL_0019:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_001e:  ldloc.1
+    IL_001f:  ldc.i4.1
+    IL_0020:  add
+    IL_0021:  stloc.1
+    IL_0022:  ldloc.1
+    IL_0023:  ldloc.0
+    IL_0024:  ldlen
+    IL_0025:  conv.i4
+    IL_0026:  blt.s      IL_0006
+
+    IL_0028:  ret
+  } 
+
+  .method public static void  testSimpleForEachArrayLoopWithTwoStatements(int32[] inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (int32[] V_0,
+             int32 V_1,
+             int32 V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldc.i4.0
+    IL_0003:  stloc.1
+    IL_0004:  br.s       IL_0032
+
+    IL_0006:  ldloc.0
+    IL_0007:  ldloc.1
+    IL_0008:  ldelem     [runtime]System.Int32
+    IL_000d:  stloc.2
+    IL_000e:  ldstr      "{0}"
+    IL_0013:  ldloc.2
+    IL_0014:  box        [runtime]System.Int32
+    IL_0019:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_001e:  ldstr      "{0}"
+    IL_0023:  ldloc.2
+    IL_0024:  box        [runtime]System.Int32
+    IL_0029:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_002e:  ldloc.1
+    IL_002f:  ldc.i4.1
+    IL_0030:  add
+    IL_0031:  stloc.1
+    IL_0032:  ldloc.1
+    IL_0033:  ldloc.0
+    IL_0034:  ldlen
+    IL_0035:  conv.i4
+    IL_0036:  blt.s      IL_0006
+
+    IL_0038:  ret
+  } 
+
+  .method public static void  testSimpleForEachListLoopWithOneStatement(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0008:  stloc.1
+    IL_0009:  br.s       IL_002b
+
+    IL_000b:  ldloc.0
+    IL_000c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0011:  stloc.2
+    IL_0012:  ldstr      "{0}"
+    IL_0017:  ldloc.2
+    IL_0018:  box        [runtime]System.Int32
+    IL_001d:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0022:  ldloc.1
+    IL_0023:  stloc.0
+    IL_0024:  ldloc.0
+    IL_0025:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_002a:  stloc.1
+    IL_002b:  ldloc.1
+    IL_002c:  brtrue.s   IL_000b
+
+    IL_002e:  ret
+  } 
+
+  .method public static void  testSimpleForEachListLoopWithTwoStatements(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> inp) cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             int32 V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.0
+    IL_0002:  ldloc.0
+    IL_0003:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_0008:  stloc.1
+    IL_0009:  br.s       IL_003b
+
+    IL_000b:  ldloc.0
+    IL_000c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+    IL_0011:  stloc.2
+    IL_0012:  ldstr      "{0}"
+    IL_0017:  ldloc.2
+    IL_0018:  box        [runtime]System.Int32
+    IL_001d:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0022:  ldstr      "{0}"
+    IL_0027:  ldloc.2
+    IL_0028:  box        [runtime]System.Int32
+    IL_002d:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0032:  ldloc.1
+    IL_0033:  stloc.0
+    IL_0034:  ldloc.0
+    IL_0035:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+    IL_003a:  stloc.1
+    IL_003b:  ldloc.1
+    IL_003c:  brtrue.s   IL_000b
+
+    IL_003e:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntRangeLoopWithOneStatement(int32 start,
+                                                                            int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0022
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0018:  ldloc.1
+    IL_0019:  ldc.i4.1
+    IL_001a:  add
+    IL_001b:  stloc.1
+    IL_001c:  ldloc.1
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.1
+    IL_001f:  add
+    IL_0020:  bne.un.s   IL_0008
+
+    IL_0022:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntRangeLoopWithTwoStatements(int32 start,
+                                                                             int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0032
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0018:  ldstr      "{0}"
+    IL_001d:  ldloc.1
+    IL_001e:  box        [runtime]System.Int32
+    IL_0023:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0028:  ldloc.1
+    IL_0029:  ldc.i4.1
+    IL_002a:  add
+    IL_002b:  stloc.1
+    IL_002c:  ldloc.1
+    IL_002d:  ldloc.0
+    IL_002e:  ldc.i4.1
+    IL_002f:  add
+    IL_0030:  bne.un.s   IL_0008
+
+    IL_0032:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntRangeLoopDownWithOneStatement(int32 start,
+                                                                                int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_1,
+             int32 V_2,
+             class [runtime]System.IDisposable V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  ldc.i4.m1
+    IL_0002:  ldarg.1
+    IL_0003:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                           int32,
+                                                                                                                                                                           int32)
+    IL_0008:  stloc.0
+    IL_0009:  ldloc.0
+    IL_000a:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_000f:  stloc.1
+    .try
+    {
+      IL_0010:  br.s       IL_0029
+
+      IL_0012:  ldloc.1
+      IL_0013:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0018:  stloc.2
+      IL_0019:  ldstr      "{0}"
+      IL_001e:  ldloc.2
+      IL_001f:  box        [runtime]System.Int32
+      IL_0024:  call       void [runtime]System.Console::WriteLine(string,
+                                                                          object)
+      IL_0029:  ldloc.1
+      IL_002a:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_002f:  brtrue.s   IL_0012
+
+      IL_0031:  leave.s    IL_0045
+
+    }  
+    finally
+    {
+      IL_0033:  ldloc.1
+      IL_0034:  isinst     [runtime]System.IDisposable
+      IL_0039:  stloc.3
+      IL_003a:  ldloc.3
+      IL_003b:  brfalse.s  IL_0044
+
+      IL_003d:  ldloc.3
+      IL_003e:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0043:  endfinally
+      IL_0044:  endfinally
+    }  
+    IL_0045:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntRangeLoopDownWithTwoStatements(int32 start,
+                                                                                 int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_1,
+             int32 V_2,
+             class [runtime]System.IDisposable V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  ldc.i4.m1
+    IL_0002:  ldarg.1
+    IL_0003:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                           int32,
+                                                                                                                                                                           int32)
+    IL_0008:  stloc.0
+    IL_0009:  ldloc.0
+    IL_000a:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_000f:  stloc.1
+    .try
+    {
+      IL_0010:  br.s       IL_0039
+
+      IL_0012:  ldloc.1
+      IL_0013:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0018:  stloc.2
+      IL_0019:  ldstr      "{0}"
+      IL_001e:  ldloc.2
+      IL_001f:  box        [runtime]System.Int32
+      IL_0024:  call       void [runtime]System.Console::WriteLine(string,
+                                                                          object)
+      IL_0029:  ldstr      "{0}"
+      IL_002e:  ldloc.2
+      IL_002f:  box        [runtime]System.Int32
+      IL_0034:  call       void [runtime]System.Console::WriteLine(string,
+                                                                          object)
+      IL_0039:  ldloc.1
+      IL_003a:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_003f:  brtrue.s   IL_0012
+
+      IL_0041:  leave.s    IL_0055
+
+    }  
+    finally
+    {
+      IL_0043:  ldloc.1
+      IL_0044:  isinst     [runtime]System.IDisposable
+      IL_0049:  stloc.3
+      IL_004a:  ldloc.3
+      IL_004b:  brfalse.s  IL_0054
+
+      IL_004d:  ldloc.3
+      IL_004e:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0053:  endfinally
+      IL_0054:  endfinally
+    }  
+    IL_0055:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntLoopWithOneStatement(int32 start,
+                                                                       int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0022
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0018:  ldloc.1
+    IL_0019:  ldc.i4.1
+    IL_001a:  add
+    IL_001b:  stloc.1
+    IL_001c:  ldloc.1
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.1
+    IL_001f:  add
+    IL_0020:  bne.un.s   IL_0008
+
+    IL_0022:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntLoopWithTwoStatements(int32 start,
+                                                                        int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.1
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  blt.s      IL_0032
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0018:  ldstr      "{0}"
+    IL_001d:  ldloc.1
+    IL_001e:  box        [runtime]System.Int32
+    IL_0023:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0028:  ldloc.1
+    IL_0029:  ldc.i4.1
+    IL_002a:  add
+    IL_002b:  stloc.1
+    IL_002c:  ldloc.1
+    IL_002d:  ldloc.0
+    IL_002e:  ldc.i4.1
+    IL_002f:  add
+    IL_0030:  bne.un.s   IL_0008
+
+    IL_0032:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntLoopDownWithOneStatement(int32 start,
+                                                                           int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.1
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.0
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  bgt.s      IL_0022
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0018:  ldloc.1
+    IL_0019:  ldc.i4.1
+    IL_001a:  sub
+    IL_001b:  stloc.1
+    IL_001c:  ldloc.1
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.1
+    IL_001f:  sub
+    IL_0020:  bne.un.s   IL_0008
+
+    IL_0022:  ret
+  } 
+
+  .method public static void  testSimpleForEachIntLoopDownWithTwoStatements(int32 start,
+                                                                            int32 stop) cil managed
+  {
+    
+    .maxstack  5
+    .locals init (int32 V_0,
+             int32 V_1)
+    IL_0000:  ldarg.1
+    IL_0001:  stloc.1
+    IL_0002:  ldarg.0
+    IL_0003:  stloc.0
+    IL_0004:  ldloc.0
+    IL_0005:  ldloc.1
+    IL_0006:  bgt.s      IL_0032
+
+    IL_0008:  ldstr      "{0}"
+    IL_000d:  ldloc.1
+    IL_000e:  box        [runtime]System.Int32
+    IL_0013:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0018:  ldstr      "{0}"
+    IL_001d:  ldloc.1
+    IL_001e:  box        [runtime]System.Int32
+    IL_0023:  call       void [runtime]System.Console::WriteLine(string,
+                                                                        object)
+    IL_0028:  ldloc.1
+    IL_0029:  ldc.i4.1
+    IL_002a:  sub
+    IL_002b:  stloc.1
+    IL_002c:  ldloc.1
+    IL_002d:  ldloc.0
+    IL_002e:  ldc.i4.1
+    IL_002f:  sub
+    IL_0030:  bne.un.s   IL_0008
+
+    IL_0032:  ret
+  } 
+
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> ListExpressionSteppingTest7() cil managed
+  {
+    
+    .maxstack  5
+    .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32> V_0,
+             class [runtime]System.Collections.Generic.IEnumerator`1<int32> V_1,
+             class [runtime]System.Collections.Generic.IEnumerable`1<int32> V_2,
+             int32 V_3,
+             class [runtime]System.IDisposable V_4)
+    IL_0000:  nop
+    IL_0001:  ldc.i4.1
+    IL_0002:  ldc.i4.1
+    IL_0003:  ldc.i4.4
+    IL_0004:  call       class [runtime]System.Collections.Generic.IEnumerable`1<int32> [FSharp.Core]Microsoft.FSharp.Core.Operators/OperatorIntrinsics::RangeInt32(int32,
+                                                                                                                                                                           int32,
+                                                                                                                                                                           int32)
+    IL_0009:  callvirt   instance class [runtime]System.Collections.Generic.IEnumerator`1<!0> class [runtime]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
+    IL_000e:  stloc.1
+    .try
+    {
+      IL_000f:  br.s       IL_0031
+
+      IL_0011:  ldloc.1
+      IL_0012:  callvirt   instance !0 class [runtime]System.Collections.Generic.IEnumerator`1<int32>::get_Current()
+      IL_0017:  stloc.3
+      IL_0018:  ldstr      "hello"
+      IL_001d:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+      IL_0022:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0027:  pop
+      IL_0028:  ldloca.s   V_0
+      IL_002a:  ldloc.3
+      IL_002b:  call       instance void valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Add(!0)
+      IL_0030:  nop
+      IL_0031:  ldloc.1
+      IL_0032:  callvirt   instance bool [runtime]System.Collections.IEnumerator::MoveNext()
+      IL_0037:  brtrue.s   IL_0011
+
+      IL_0039:  ldnull
+      IL_003a:  stloc.2
+      IL_003b:  leave.s    IL_0052
+
+    }  
+    finally
+    {
+      IL_003d:  ldloc.1
+      IL_003e:  isinst     [runtime]System.IDisposable
+      IL_0043:  stloc.s    V_4
+      IL_0045:  ldloc.s    V_4
+      IL_0047:  brfalse.s  IL_0051
+
+      IL_0049:  ldloc.s    V_4
+      IL_004b:  callvirt   instance void [runtime]System.IDisposable::Dispose()
+      IL_0050:  endfinally
+      IL_0051:  endfinally
+    }  
+    IL_0052:  ldloc.2
+    IL_0053:  pop
+    IL_0054:  ldloca.s   V_0
+    IL_0056:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> valuetype [FSharp.Core]Microsoft.FSharp.Core.CompilerServices.ListCollector`1<int32>::Close()
+    IL_005b:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest7::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$SeqExpressionSteppingTest7::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0,
+             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+             class [runtime]System.Exception V_2,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> V_3)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 SeqExpressionSteppingTest7::r@4
+    IL_0006:  ldstr      "res = %A"
+    IL_000b:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor(string)
+    IL_0010:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0015:  stloc.0
+    .try
+    {
+      IL_0016:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!!0> SeqExpressionSteppingTest7::f<int32>()
+      IL_001b:  stloc.1
+      IL_001c:  leave.s    IL_004b
+
+    }  
+    catch [runtime]System.Object 
+    {
+      IL_001e:  castclass  [runtime]System.Exception
+      IL_0023:  stloc.2
+      IL_0024:  ldloc.2
+      IL_0025:  call       class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<string> [FSharp.Core]Microsoft.FSharp.Core.Operators::FailurePattern(class [runtime]System.Exception)
+      IL_002a:  stloc.3
+      IL_002b:  ldloc.3
+      IL_002c:  brfalse.s  IL_0040
+
+      IL_002e:  call       int32 SeqExpressionSteppingTest7::get_r()
+      IL_0033:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+      IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_003d:  stloc.1
+      IL_003e:  leave.s    IL_004b
+
+      IL_0040:  rethrow
+      IL_0042:  ldnull
+      IL_0043:  unbox.any  class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+      IL_0048:  stloc.1
+      IL_0049:  leave.s    IL_004b
+
+    }  
+    IL_004b:  ldloc.0
+    IL_004c:  ldloc.1
+    IL_004d:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0052:  pop
+    IL_0053:  ret
+  } 
+
+  .property int32 r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .set void SeqExpressionSteppingTest7::set_r(int32)
+    .get int32 SeqExpressionSteppingTest7::get_r()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$SeqExpressionSteppingTest7
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void SeqExpressionSteppingTest7::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionTailCalls/SeqExpressionTailCalls.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionTailCalls/SeqExpressionTailCalls.fs
index 1d6244f9f7b..55245346fa0 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionTailCalls/SeqExpressionTailCalls.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SeqExpressionTailCalls/SeqExpressionTailCalls.fs
@@ -7,6 +7,7 @@ open FSharp.Test.Compiler
 
 module SeqExpressionTailCalls =
 
+    // Note: no realsignature variations are performed because these test cases do not involve any static initialization
     let verifyCompilation compilation =
         compilation
         |> withOptions [ "--test:EmitFeeFeeAs100001" ]
@@ -25,6 +26,6 @@ module SeqExpressionTailCalls =
 
     // SOURCE=SeqExpressionTailCalls02.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd SeqExpressionTailCalls02.exe"	# SeqExpressionTailCalls02.fs -
     [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"SeqExpressionTailCalls02.fs"|])>]
-    let ``SeqExpressionSteppingTest02_fs`` compilation =
+    let ``SeqExpressionTailCalls02_fs`` compilation =
         compilation
         |> verifyCompilation
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/SerializableAttribute.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/SerializableAttribute.fs
index 0dd543a2eef..3a801ed3dce 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/SerializableAttribute.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/SerializableAttribute.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open Xunit
 open System.IO
@@ -18,27 +18,60 @@ module SerializableAttribute =
         |> verifyILBaseline
 
     // SOURCE=ToplevelModule.fs    SCFLAGS="-a -g --out:TopLevelModule.dll --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ToplevelModule.dll"		# ToplevelModule.fs - Desktop
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ToplevelModule.fs"|])>]
-    let ``ToplevelModule_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ToplevelModule.fs"|])>]
+    let ``ToplevelModule_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    // SOURCE=ToplevelModule.fs    SCFLAGS="-a -g --out:TopLevelModule.dll --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ToplevelModule.dll"		# ToplevelModule.fs - Desktop
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ToplevelModule.fs"|])>]
+    let ``ToplevelModule_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     // SOURCE=ToplevelNamespace.fs SCFLAGS="-a -g --out:ToplevelNamespace.dll --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ToplevelNamespace.dll"		# ToplevelNamespace.fs - Desktop
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ToplevelNamespace.fs"|])>]
-    let ``ToplevelNamespace_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ToplevelNamespace.fs"|])>]
+    let ``ToplevelNamespace_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    // SOURCE=ToplevelNamespace.fs SCFLAGS="-a -g --out:ToplevelNamespace.dll --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ToplevelNamespace.dll"		# ToplevelNamespace.fs - Desktop
+    [<Theory; Directory(__SOURCE_DIRECTORY__,BaselineSuffix=".RealInternalSignatureOff",  Includes=[|"ToplevelNamespace.fs"|])>]
+    let ``ToplevelNamespacec_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     // SOURCE=ToplevelModule.fs    SCFLAGS="-a -g --langversion:6.0 --out:TopLevelModule-preview.dll --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ToplevelModule-preview.dll"		# ToplevelModule.fs - Desktop preview
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ToplevelModule60.fs"|])>]
-    let ``ToplevelModule_LangVersion60_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ToplevelModule60.fs"|])>]
+    let ``ToplevelModule_LangVersion60_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> withLangVersion60
+        |> verifyCompilation
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ToplevelModule60.fs"|])>]
+    let ``ToplevelModule_LangVersion60_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> withLangVersion60
+        |> verifyCompilation
+
+    // SOURCE=ToplevelNamespace.fs SCFLAGS="-a -g --langversion:6.0 --out:ToplevelNamespace-preview.dll --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ToplevelNamespace-preview.dll"		# ToplevelNamespace.fs - Desktop preview
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ToplevelNamespace60.fs"|])>]
+    let ``ToplevelNamespace_LangVersion60_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> withLangVersion60
         |> verifyCompilation
 
     // SOURCE=ToplevelNamespace.fs SCFLAGS="-a -g --langversion:6.0 --out:ToplevelNamespace-preview.dll --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ToplevelNamespace-preview.dll"		# ToplevelNamespace.fs - Desktop preview
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ToplevelNamespace60.fs"|])>]
-    let ``ToplevelNamespace_LangVersion60_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ToplevelNamespace60.fs"|])>]
+    let ``ToplevelNamespace_LangVersion60_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> withLangVersion60
         |> verifyCompilation
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOff.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOff.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOff.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOff.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOff.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOff.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOff.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOff.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOn.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOn.il.net472.debug.bsl
new file mode 100644
index 00000000000..3a5e5b10025
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOn.il.net472.debug.bsl
@@ -0,0 +1,1639 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed ABC
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Expr
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class ABC/Expr>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class ABC/Expr>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                   61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field assembly initonly int32 item
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public static class ABC/Expr NewNum(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void ABC/Expr::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+    {
+      .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                              class [runtime]System.Type) = ( 01 00 60 06 00 00 08 41 42 43 2B 45 78 70 72 00   
+                                                                                                                               00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 ABC/Expr::item
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Item() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 ABC/Expr::item
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/Expr>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4,
+               class [runtime]System.Collections.IComparer V_5,
+               int32 V_6,
+               int32 V_7)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_003b
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_0039
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.0
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.1
+      IL_001a:  ldfld      int32 ABC/Expr::item
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.2
+      IL_0022:  stloc.s    V_5
+      IL_0024:  ldloc.3
+      IL_0025:  stloc.s    V_6
+      IL_0027:  ldloc.s    V_4
+      IL_0029:  stloc.s    V_7
+      IL_002b:  ldloc.s    V_6
+      IL_002d:  ldloc.s    V_7
+      IL_002f:  cgt
+      IL_0031:  ldloc.s    V_6
+      IL_0033:  ldloc.s    V_7
+      IL_0035:  clt
+      IL_0037:  sub
+      IL_0038:  ret
+
+      IL_0039:  ldc.i4.1
+      IL_003a:  ret
+
+      IL_003b:  ldarg.1
+      IL_003c:  brfalse.s  IL_0040
+
+      IL_003e:  ldc.i4.m1
+      IL_003f:  ret
+
+      IL_0040:  ldc.i4.0
+      IL_0041:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  ABC/Expr
+      IL_0007:  callvirt   instance int32 ABC/Expr::CompareTo(class ABC/Expr)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class ABC/Expr V_2,
+               class [runtime]System.Collections.IComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IComparer V_6,
+               int32 V_7,
+               int32 V_8)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_0045
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  ABC/Expr
+      IL_0010:  brfalse.s  IL_0043
+
+      IL_0012:  ldarg.0
+      IL_0013:  pop
+      IL_0014:  ldarg.0
+      IL_0015:  stloc.1
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  ldarg.2
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.1
+      IL_001b:  ldfld      int32 ABC/Expr::item
+      IL_0020:  stloc.s    V_4
+      IL_0022:  ldloc.2
+      IL_0023:  ldfld      int32 ABC/Expr::item
+      IL_0028:  stloc.s    V_5
+      IL_002a:  ldloc.3
+      IL_002b:  stloc.s    V_6
+      IL_002d:  ldloc.s    V_4
+      IL_002f:  stloc.s    V_7
+      IL_0031:  ldloc.s    V_5
+      IL_0033:  stloc.s    V_8
+      IL_0035:  ldloc.s    V_7
+      IL_0037:  ldloc.s    V_8
+      IL_0039:  cgt
+      IL_003b:  ldloc.s    V_7
+      IL_003d:  ldloc.s    V_8
+      IL_003f:  clt
+      IL_0041:  sub
+      IL_0042:  ret
+
+      IL_0043:  ldc.i4.1
+      IL_0044:  ret
+
+      IL_0045:  ldarg.1
+      IL_0046:  unbox.any  ABC/Expr
+      IL_004b:  brfalse.s  IL_004f
+
+      IL_004d:  ldc.i4.m1
+      IL_004e:  ret
+
+      IL_004f:  ldc.i4.0
+      IL_0050:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class ABC/Expr V_1,
+               class [runtime]System.Collections.IEqualityComparer V_2,
+               int32 V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0029
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldarg.0
+      IL_0008:  stloc.1
+      IL_0009:  ldc.i4.0
+      IL_000a:  stloc.0
+      IL_000b:  ldc.i4     0x9e3779b9
+      IL_0010:  ldarg.1
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.2
+      IL_001a:  stloc.s    V_4
+      IL_001c:  ldloc.3
+      IL_001d:  ldloc.0
+      IL_001e:  ldc.i4.6
+      IL_001f:  shl
+      IL_0020:  ldloc.0
+      IL_0021:  ldc.i4.2
+      IL_0022:  shr
+      IL_0023:  add
+      IL_0024:  add
+      IL_0025:  add
+      IL_0026:  stloc.0
+      IL_0027:  ldloc.0
+      IL_0028:  ret
+
+      IL_0029:  ldc.i4.0
+      IL_002a:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class ABC/Expr V_2,
+               class ABC/Expr V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4,
+               int32 V_5,
+               int32 V_6,
+               class [runtime]System.Collections.IEqualityComparer V_7)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0035
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     ABC/Expr
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0033
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  pop
+      IL_0011:  ldarg.0
+      IL_0012:  stloc.2
+      IL_0013:  ldloc.1
+      IL_0014:  stloc.3
+      IL_0015:  ldarg.2
+      IL_0016:  stloc.s    V_4
+      IL_0018:  ldloc.2
+      IL_0019:  ldfld      int32 ABC/Expr::item
+      IL_001e:  stloc.s    V_5
+      IL_0020:  ldloc.3
+      IL_0021:  ldfld      int32 ABC/Expr::item
+      IL_0026:  stloc.s    V_6
+      IL_0028:  ldloc.s    V_4
+      IL_002a:  stloc.s    V_7
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  ldloc.s    V_6
+      IL_0030:  ceq
+      IL_0032:  ret
+
+      IL_0033:  ldc.i4.0
+      IL_0034:  ret
+
+      IL_0035:  ldarg.1
+      IL_0036:  ldnull
+      IL_0037:  cgt.un
+      IL_0039:  ldc.i4.0
+      IL_003a:  ceq
+      IL_003c:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001d
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001b
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldloc.0
+      IL_000d:  ldfld      int32 ABC/Expr::item
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  ceq
+      IL_001a:  ret
+
+      IL_001b:  ldc.i4.0
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  ldnull
+      IL_001f:  cgt.un
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool ABC/Expr::Equals(class ABC/Expr)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 ABC/Expr::get_Tag()
+    } 
+    .property instance int32 Item()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .get instance int32 ABC/Expr::get_Item()
+    } 
+  } 
+
+  .class auto ansi serializable nested public beforefieldinit MyExn
+         extends [runtime]System.Exception
+         implements [runtime]System.Collections.IStructuralEquatable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+    .field assembly int32 Data0@
+    .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 ABC/MyExn::Data0@
+      IL_000d:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method family specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  ldarg.2
+      IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                           valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_Data0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 ABC/MyExn::Data0@
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string get_Message() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/MyExn>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/MyExn,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1,
+               int32 V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0027
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldc.i4     0x9e3779b9
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  castclass  ABC/MyExn
+      IL_0012:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0017:  stloc.2
+      IL_0018:  ldloc.1
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.2
+      IL_001b:  ldloc.0
+      IL_001c:  ldc.i4.6
+      IL_001d:  shl
+      IL_001e:  ldloc.0
+      IL_001f:  ldc.i4.2
+      IL_0020:  shr
+      IL_0021:  add
+      IL_0022:  add
+      IL_0023:  add
+      IL_0024:  stloc.0
+      IL_0025:  ldloc.0
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual instance bool 
+            Equals(object obj,
+                   class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1,
+               object V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IEqualityComparer V_6)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0046
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     [runtime]System.Exception
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0044
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldloc.0
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.2
+      IL_0012:  isinst     ABC/MyExn
+      IL_0017:  ldnull
+      IL_0018:  cgt.un
+      IL_001a:  brfalse.s  IL_0042
+
+      IL_001c:  ldarg.2
+      IL_001d:  stloc.3
+      IL_001e:  ldarg.0
+      IL_001f:  castclass  ABC/MyExn
+      IL_0024:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0029:  stloc.s    V_4
+      IL_002b:  ldloc.1
+      IL_002c:  castclass  ABC/MyExn
+      IL_0031:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0036:  stloc.s    V_5
+      IL_0038:  ldloc.3
+      IL_0039:  stloc.s    V_6
+      IL_003b:  ldloc.s    V_4
+      IL_003d:  ldloc.s    V_5
+      IL_003f:  ceq
+      IL_0041:  ret
+
+      IL_0042:  ldc.i4.0
+      IL_0043:  ret
+
+      IL_0044:  ldc.i4.0
+      IL_0045:  ret
+
+      IL_0046:  ldarg.1
+      IL_0047:  ldnull
+      IL_0048:  cgt.un
+      IL_004a:  ldc.i4.0
+      IL_004b:  ceq
+      IL_004d:  ret
+    } 
+
+    .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0030
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002e
+
+      IL_0006:  ldarg.1
+      IL_0007:  stloc.0
+      IL_0008:  ldloc.0
+      IL_0009:  isinst     ABC/MyExn
+      IL_000e:  ldnull
+      IL_000f:  cgt.un
+      IL_0011:  brfalse.s  IL_002c
+
+      IL_0013:  ldarg.0
+      IL_0014:  castclass  ABC/MyExn
+      IL_0019:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_001e:  ldarg.1
+      IL_001f:  castclass  ABC/MyExn
+      IL_0024:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0029:  ceq
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+
+      IL_0030:  ldarg.1
+      IL_0031:  ldnull
+      IL_0032:  cgt.un
+      IL_0034:  ldc.i4.0
+      IL_0035:  ceq
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual instance bool Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     [runtime]System.Exception
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool ABC/MyExn::Equals(class [runtime]System.Exception)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Data0()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance int32 ABC/MyExn::get_Data0()
+    } 
+  } 
+
+  .class auto ansi serializable nested public A
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly string x
+    .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldarg.1
+      IL_000a:  stfld      string ABC/A::x
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance string  get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string ABC/A::x
+      IL_0006:  ret
+    } 
+
+    .property instance string X()
+    {
+      .get instance string ABC/A::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public ABC
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested public beforefieldinit Expr
+           extends [runtime]System.Object
+           implements class [runtime]System.IEquatable`1<class ABC/ABC/Expr>,
+                      [runtime]System.Collections.IStructuralEquatable,
+                      class [runtime]System.IComparable`1<class ABC/ABC/Expr>,
+                      [runtime]System.IComparable,
+                      [runtime]System.Collections.IStructuralComparable
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                     61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public static class ABC/ABC/Expr NewNum(int32 item) cil managed
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void ABC/ABC/Expr::.ctor(int32)
+        IL_0006:  ret
+      } 
+
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0C 41 42 43 2B 41 42 43 2B 45   
+                                                                                                                                 78 70 72 00 00 )                                  
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 ABC/ABC/Expr::item
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Tag() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  pop
+        IL_0002:  ldc.i4.0
+        IL_0003:  ret
+      } 
+
+      .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+0.8A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public strict virtual instance string ToString() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/ABC/Expr>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(class ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IComparer V_2,
+                 int32 V_3,
+                 int32 V_4,
+                 class [runtime]System.Collections.IComparer V_5,
+                 int32 V_6,
+                 int32 V_7)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_003b
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_0039
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.0
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.1
+        IL_001a:  ldfld      int32 ABC/ABC/Expr::item
+        IL_001f:  stloc.s    V_4
+        IL_0021:  ldloc.2
+        IL_0022:  stloc.s    V_5
+        IL_0024:  ldloc.3
+        IL_0025:  stloc.s    V_6
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  stloc.s    V_7
+        IL_002b:  ldloc.s    V_6
+        IL_002d:  ldloc.s    V_7
+        IL_002f:  cgt
+        IL_0031:  ldloc.s    V_6
+        IL_0033:  ldloc.s    V_7
+        IL_0035:  clt
+        IL_0037:  sub
+        IL_0038:  ret
+
+        IL_0039:  ldc.i4.1
+        IL_003a:  ret
+
+        IL_003b:  ldarg.1
+        IL_003c:  brfalse.s  IL_0040
+
+        IL_003e:  ldc.i4.m1
+        IL_003f:  ret
+
+        IL_0040:  ldc.i4.0
+        IL_0041:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  unbox.any  ABC/ABC/Expr
+        IL_0007:  callvirt   instance int32 ABC/ABC/Expr::CompareTo(class ABC/ABC/Expr)
+        IL_000c:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance int32  CompareTo(object obj,
+                                        class [runtime]System.Collections.IComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class ABC/ABC/Expr V_2,
+                 class [runtime]System.Collections.IComparer V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class [runtime]System.Collections.IComparer V_6,
+                 int32 V_7,
+                 int32 V_8)
+        IL_0000:  ldarg.1
+        IL_0001:  unbox.any  ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  brfalse.s  IL_0045
+
+        IL_000a:  ldarg.1
+        IL_000b:  unbox.any  ABC/ABC/Expr
+        IL_0010:  brfalse.s  IL_0043
+
+        IL_0012:  ldarg.0
+        IL_0013:  pop
+        IL_0014:  ldarg.0
+        IL_0015:  stloc.1
+        IL_0016:  ldloc.0
+        IL_0017:  stloc.2
+        IL_0018:  ldarg.2
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.1
+        IL_001b:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0020:  stloc.s    V_4
+        IL_0022:  ldloc.2
+        IL_0023:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0028:  stloc.s    V_5
+        IL_002a:  ldloc.3
+        IL_002b:  stloc.s    V_6
+        IL_002d:  ldloc.s    V_4
+        IL_002f:  stloc.s    V_7
+        IL_0031:  ldloc.s    V_5
+        IL_0033:  stloc.s    V_8
+        IL_0035:  ldloc.s    V_7
+        IL_0037:  ldloc.s    V_8
+        IL_0039:  cgt
+        IL_003b:  ldloc.s    V_7
+        IL_003d:  ldloc.s    V_8
+        IL_003f:  clt
+        IL_0041:  sub
+        IL_0042:  ret
+
+        IL_0043:  ldc.i4.1
+        IL_0044:  ret
+
+        IL_0045:  ldarg.1
+        IL_0046:  unbox.any  ABC/ABC/Expr
+        IL_004b:  brfalse.s  IL_004f
+
+        IL_004d:  ldc.i4.m1
+        IL_004e:  ret
+
+        IL_004f:  ldc.i4.0
+        IL_0050:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IEqualityComparer V_2,
+                 int32 V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0029
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldarg.0
+        IL_0006:  pop
+        IL_0007:  ldarg.0
+        IL_0008:  stloc.1
+        IL_0009:  ldc.i4.0
+        IL_000a:  stloc.0
+        IL_000b:  ldc.i4     0x9e3779b9
+        IL_0010:  ldarg.1
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.2
+        IL_001a:  stloc.s    V_4
+        IL_001c:  ldloc.3
+        IL_001d:  ldloc.0
+        IL_001e:  ldc.i4.6
+        IL_001f:  shl
+        IL_0020:  ldloc.0
+        IL_0021:  ldc.i4.2
+        IL_0022:  shr
+        IL_0023:  add
+        IL_0024:  add
+        IL_0025:  add
+        IL_0026:  stloc.0
+        IL_0027:  ldloc.0
+        IL_0028:  ret
+
+        IL_0029:  ldc.i4.0
+        IL_002a:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 ABC/ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance bool  Equals(object obj,
+                                    class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class ABC/ABC/Expr V_2,
+                 class ABC/ABC/Expr V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4,
+                 int32 V_5,
+                 int32 V_6,
+                 class [runtime]System.Collections.IEqualityComparer V_7)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0035
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     ABC/ABC/Expr
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0033
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldarg.0
+        IL_0010:  pop
+        IL_0011:  ldarg.0
+        IL_0012:  stloc.2
+        IL_0013:  ldloc.1
+        IL_0014:  stloc.3
+        IL_0015:  ldarg.2
+        IL_0016:  stloc.s    V_4
+        IL_0018:  ldloc.2
+        IL_0019:  ldfld      int32 ABC/ABC/Expr::item
+        IL_001e:  stloc.s    V_5
+        IL_0020:  ldloc.3
+        IL_0021:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0026:  stloc.s    V_6
+        IL_0028:  ldloc.s    V_4
+        IL_002a:  stloc.s    V_7
+        IL_002c:  ldloc.s    V_5
+        IL_002e:  ldloc.s    V_6
+        IL_0030:  ceq
+        IL_0032:  ret
+
+        IL_0033:  ldc.i4.0
+        IL_0034:  ret
+
+        IL_0035:  ldarg.1
+        IL_0036:  ldnull
+        IL_0037:  cgt.un
+        IL_0039:  ldc.i4.0
+        IL_003a:  ceq
+        IL_003c:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(class ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_001d
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_001b
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldloc.0
+        IL_000d:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  ceq
+        IL_001a:  ret
+
+        IL_001b:  ldc.i4.0
+        IL_001c:  ret
+
+        IL_001d:  ldarg.1
+        IL_001e:  ldnull
+        IL_001f:  cgt.un
+        IL_0021:  ldc.i4.0
+        IL_0022:  ceq
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool ABC/ABC/Expr::Equals(class ABC/ABC/Expr)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Tag()
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+        .get instance int32 ABC/ABC/Expr::get_Tag()
+      } 
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 ABC/ABC/Expr::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit MyExn
+           extends [runtime]System.Exception
+           implements [runtime]System.Collections.IStructuralEquatable
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+      .field assembly int32 Data0@
+      .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 ABC/ABC/MyExn::Data0@
+        IL_000d:  ret
+      } 
+
+      .method public specialname rtspecialname instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method family specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  ldarg.2
+        IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                             valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+        IL_0008:  ret
+      } 
+
+      .method public hidebysig specialname instance int32  get_Data0() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 ABC/ABC/MyExn::Data0@
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance string get_Message() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/ABC/MyExn>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/MyExn,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [runtime]System.Collections.IEqualityComparer V_1,
+                 int32 V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0027
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldc.i4     0x9e3779b9
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldarg.0
+        IL_000d:  castclass  ABC/ABC/MyExn
+        IL_0012:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0017:  stloc.2
+        IL_0018:  ldloc.1
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.2
+        IL_001b:  ldloc.0
+        IL_001c:  ldc.i4.6
+        IL_001d:  shl
+        IL_001e:  ldloc.0
+        IL_001f:  ldc.i4.2
+        IL_0020:  shr
+        IL_0021:  add
+        IL_0022:  add
+        IL_0023:  add
+        IL_0024:  stloc.0
+        IL_0025:  ldloc.0
+        IL_0026:  ret
+
+        IL_0027:  ldc.i4.0
+        IL_0028:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 ABC/ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual instance bool 
+              Equals(object obj,
+                     class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1,
+                 object V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class [runtime]System.Collections.IEqualityComparer V_6)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0046
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     [runtime]System.Exception
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0044
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldloc.0
+        IL_0010:  stloc.2
+        IL_0011:  ldloc.2
+        IL_0012:  isinst     ABC/ABC/MyExn
+        IL_0017:  ldnull
+        IL_0018:  cgt.un
+        IL_001a:  brfalse.s  IL_0042
+
+        IL_001c:  ldarg.2
+        IL_001d:  stloc.3
+        IL_001e:  ldarg.0
+        IL_001f:  castclass  ABC/ABC/MyExn
+        IL_0024:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0029:  stloc.s    V_4
+        IL_002b:  ldloc.1
+        IL_002c:  castclass  ABC/ABC/MyExn
+        IL_0031:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0036:  stloc.s    V_5
+        IL_0038:  ldloc.3
+        IL_0039:  stloc.s    V_6
+        IL_003b:  ldloc.s    V_4
+        IL_003d:  ldloc.s    V_5
+        IL_003f:  ceq
+        IL_0041:  ret
+
+        IL_0042:  ldc.i4.0
+        IL_0043:  ret
+
+        IL_0044:  ldc.i4.0
+        IL_0045:  ret
+
+        IL_0046:  ldarg.1
+        IL_0047:  ldnull
+        IL_0048:  cgt.un
+        IL_004a:  ldc.i4.0
+        IL_004b:  ceq
+        IL_004d:  ret
+      } 
+
+      .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (object V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0030
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002e
+
+        IL_0006:  ldarg.1
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  isinst     ABC/ABC/MyExn
+        IL_000e:  ldnull
+        IL_000f:  cgt.un
+        IL_0011:  brfalse.s  IL_002c
+
+        IL_0013:  ldarg.0
+        IL_0014:  castclass  ABC/ABC/MyExn
+        IL_0019:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_001e:  ldarg.1
+        IL_001f:  castclass  ABC/ABC/MyExn
+        IL_0024:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ceq
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+
+        IL_0030:  ldarg.1
+        IL_0031:  ldnull
+        IL_0032:  cgt.un
+        IL_0034:  ldc.i4.0
+        IL_0035:  ceq
+        IL_0037:  ret
+      } 
+
+      .method public hidebysig virtual instance bool Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     [runtime]System.Exception
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool ABC/ABC/MyExn::Equals(class [runtime]System.Exception)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Data0()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+        .get instance int32 ABC/ABC/MyExn::get_Data0()
+      } 
+    } 
+
+    .class auto ansi serializable nested public A
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+      .field assembly string x
+      .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  ldarg.1
+        IL_000a:  stfld      string ABC/ABC/A::x
+        IL_000f:  ret
+      } 
+
+      .method public hidebysig specialname instance string  get_X() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      string ABC/ABC/A::x
+        IL_0006:  ret
+      } 
+
+      .property instance string X()
+      {
+        .get instance string ABC/ABC/A::get_X()
+      } 
+    } 
+
+    .method public static int32  'add'(int32 x,
+                                       int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public specialname static string get_greeting() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  ret
+    } 
+
+    .property string greeting()
+    {
+      .get string ABC/ABC::get_greeting()
+    } 
+  } 
+
+  .method public static int32  'add'(int32 x,
+                                     int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public specialname static string get_greeting() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello"
+    IL_0005:  ret
+  } 
+
+  .property string greeting()
+  {
+    .get string ABC::get_greeting()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$ABC
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+.class private auto ansi serializable sealed System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+       extends [runtime]System.Enum
+{
+  .custom instance void [runtime]System.FlagsAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field public specialname rtspecialname int32 value__
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes All = int32(0xFFFFFFFF)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes None = int32(0x00000000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicParameterlessConstructor = int32(0x00000001)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicConstructors = int32(0x00000003)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicConstructors = int32(0x00000004)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicMethods = int32(0x00000008)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicMethods = int32(0x00000010)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicFields = int32(0x00000020)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicFields = int32(0x00000040)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicNestedTypes = int32(0x00000080)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicNestedTypes = int32(0x00000100)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicProperties = int32(0x00000200)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicProperties = int32(0x00000400)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicEvents = int32(0x00000800)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicEvents = int32(0x00001000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes Interfaces = int32(0x00002000)
+} 
+
+.class private auto ansi beforefieldinit System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute
+       extends [runtime]System.Attribute
+{
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private class [runtime]System.Type Type@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public specialname rtspecialname 
+          instance void  .ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType,
+                               class [runtime]System.Type Type) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Attribute::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_000d:  ldarg.0
+    IL_000e:  ldarg.2
+    IL_000f:  stfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0014:  ret
+  } 
+
+  .method public hidebysig specialname instance class [runtime]System.Type get_Type() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes get_MemberType() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_0006:  ret
+  } 
+
+  .property instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+          MemberType()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_MemberType()
+  } 
+  .property instance class [runtime]System.Type
+          Type()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_Type()
+  } 
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOn.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOn.il.net472.release.bsl
new file mode 100644
index 00000000000..9fcc461f28d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOn.il.net472.release.bsl
@@ -0,0 +1,1543 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed ABC
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Expr
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class ABC/Expr>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class ABC/Expr>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                   61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field assembly initonly int32 item
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public static class ABC/Expr NewNum(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void ABC/Expr::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+    {
+      .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                              class [runtime]System.Type) = ( 01 00 60 06 00 00 08 41 42 43 2B 45 78 70 72 00   
+                                                                                                                               00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 ABC/Expr::item
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Item() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 ABC/Expr::item
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/Expr>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_002f
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002d
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.0
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.1
+      IL_001a:  ldfld      int32 ABC/Expr::item
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.3
+      IL_0022:  ldloc.s    V_4
+      IL_0024:  cgt
+      IL_0026:  ldloc.3
+      IL_0027:  ldloc.s    V_4
+      IL_0029:  clt
+      IL_002b:  sub
+      IL_002c:  ret
+
+      IL_002d:  ldc.i4.1
+      IL_002e:  ret
+
+      IL_002f:  ldarg.1
+      IL_0030:  brfalse.s  IL_0034
+
+      IL_0032:  ldc.i4.m1
+      IL_0033:  ret
+
+      IL_0034:  ldc.i4.0
+      IL_0035:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  ABC/Expr
+      IL_0007:  callvirt   instance int32 ABC/Expr::CompareTo(class ABC/Expr)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class ABC/Expr V_2,
+               class [runtime]System.Collections.IComparer V_3,
+               int32 V_4,
+               int32 V_5)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_003a
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  ABC/Expr
+      IL_0010:  brfalse.s  IL_0038
+
+      IL_0012:  ldarg.0
+      IL_0013:  pop
+      IL_0014:  ldarg.0
+      IL_0015:  stloc.1
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  ldarg.2
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.1
+      IL_001b:  ldfld      int32 ABC/Expr::item
+      IL_0020:  stloc.s    V_4
+      IL_0022:  ldloc.2
+      IL_0023:  ldfld      int32 ABC/Expr::item
+      IL_0028:  stloc.s    V_5
+      IL_002a:  ldloc.s    V_4
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  cgt
+      IL_0030:  ldloc.s    V_4
+      IL_0032:  ldloc.s    V_5
+      IL_0034:  clt
+      IL_0036:  sub
+      IL_0037:  ret
+
+      IL_0038:  ldc.i4.1
+      IL_0039:  ret
+
+      IL_003a:  ldarg.1
+      IL_003b:  unbox.any  ABC/Expr
+      IL_0040:  brfalse.s  IL_0044
+
+      IL_0042:  ldc.i4.m1
+      IL_0043:  ret
+
+      IL_0044:  ldc.i4.0
+      IL_0045:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class ABC/Expr V_1,
+               class [runtime]System.Collections.IEqualityComparer V_2)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0024
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldarg.0
+      IL_0008:  stloc.1
+      IL_0009:  ldc.i4.0
+      IL_000a:  stloc.0
+      IL_000b:  ldc.i4     0x9e3779b9
+      IL_0010:  ldarg.1
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  ldloc.0
+      IL_0019:  ldc.i4.6
+      IL_001a:  shl
+      IL_001b:  ldloc.0
+      IL_001c:  ldc.i4.2
+      IL_001d:  shr
+      IL_001e:  add
+      IL_001f:  add
+      IL_0020:  add
+      IL_0021:  stloc.0
+      IL_0022:  ldloc.0
+      IL_0023:  ret
+
+      IL_0024:  ldc.i4.0
+      IL_0025:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class ABC/Expr V_2,
+               class ABC/Expr V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0029
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     ABC/Expr
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0027
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  pop
+      IL_0011:  ldarg.0
+      IL_0012:  stloc.2
+      IL_0013:  ldloc.1
+      IL_0014:  stloc.3
+      IL_0015:  ldarg.2
+      IL_0016:  stloc.s    V_4
+      IL_0018:  ldloc.2
+      IL_0019:  ldfld      int32 ABC/Expr::item
+      IL_001e:  ldloc.3
+      IL_001f:  ldfld      int32 ABC/Expr::item
+      IL_0024:  ceq
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+
+      IL_0029:  ldarg.1
+      IL_002a:  ldnull
+      IL_002b:  cgt.un
+      IL_002d:  ldc.i4.0
+      IL_002e:  ceq
+      IL_0030:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001d
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001b
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldloc.0
+      IL_000d:  ldfld      int32 ABC/Expr::item
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  ceq
+      IL_001a:  ret
+
+      IL_001b:  ldc.i4.0
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  ldnull
+      IL_001f:  cgt.un
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool ABC/Expr::Equals(class ABC/Expr)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 ABC/Expr::get_Tag()
+    } 
+    .property instance int32 Item()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .get instance int32 ABC/Expr::get_Item()
+    } 
+  } 
+
+  .class auto ansi serializable nested public beforefieldinit MyExn
+         extends [runtime]System.Exception
+         implements [runtime]System.Collections.IStructuralEquatable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+    .field assembly int32 Data0@
+    .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 ABC/MyExn::Data0@
+      IL_000d:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method family specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  ldarg.2
+      IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                           valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_Data0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 ABC/MyExn::Data0@
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string get_Message() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/MyExn>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/MyExn,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0023
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldc.i4     0x9e3779b9
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  castclass  ABC/MyExn
+      IL_0012:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0017:  ldloc.0
+      IL_0018:  ldc.i4.6
+      IL_0019:  shl
+      IL_001a:  ldloc.0
+      IL_001b:  ldc.i4.2
+      IL_001c:  shr
+      IL_001d:  add
+      IL_001e:  add
+      IL_001f:  add
+      IL_0020:  stloc.0
+      IL_0021:  ldloc.0
+      IL_0022:  ret
+
+      IL_0023:  ldc.i4.0
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual instance bool 
+            Equals(object obj,
+                   class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1,
+               object V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_003b
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     [runtime]System.Exception
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0039
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldloc.0
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.2
+      IL_0012:  isinst     ABC/MyExn
+      IL_0017:  ldnull
+      IL_0018:  cgt.un
+      IL_001a:  brfalse.s  IL_0037
+
+      IL_001c:  ldarg.2
+      IL_001d:  stloc.3
+      IL_001e:  ldarg.0
+      IL_001f:  castclass  ABC/MyExn
+      IL_0024:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0029:  ldloc.1
+      IL_002a:  castclass  ABC/MyExn
+      IL_002f:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0034:  ceq
+      IL_0036:  ret
+
+      IL_0037:  ldc.i4.0
+      IL_0038:  ret
+
+      IL_0039:  ldc.i4.0
+      IL_003a:  ret
+
+      IL_003b:  ldarg.1
+      IL_003c:  ldnull
+      IL_003d:  cgt.un
+      IL_003f:  ldc.i4.0
+      IL_0040:  ceq
+      IL_0042:  ret
+    } 
+
+    .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0030
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002e
+
+      IL_0006:  ldarg.1
+      IL_0007:  stloc.0
+      IL_0008:  ldloc.0
+      IL_0009:  isinst     ABC/MyExn
+      IL_000e:  ldnull
+      IL_000f:  cgt.un
+      IL_0011:  brfalse.s  IL_002c
+
+      IL_0013:  ldarg.0
+      IL_0014:  castclass  ABC/MyExn
+      IL_0019:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_001e:  ldarg.1
+      IL_001f:  castclass  ABC/MyExn
+      IL_0024:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0029:  ceq
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+
+      IL_0030:  ldarg.1
+      IL_0031:  ldnull
+      IL_0032:  cgt.un
+      IL_0034:  ldc.i4.0
+      IL_0035:  ceq
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual instance bool Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     [runtime]System.Exception
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool ABC/MyExn::Equals(class [runtime]System.Exception)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Data0()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance int32 ABC/MyExn::get_Data0()
+    } 
+  } 
+
+  .class auto ansi serializable nested public A
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly string x
+    .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldarg.1
+      IL_000a:  stfld      string ABC/A::x
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance string  get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string ABC/A::x
+      IL_0006:  ret
+    } 
+
+    .property instance string X()
+    {
+      .get instance string ABC/A::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public ABC
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested public beforefieldinit Expr
+           extends [runtime]System.Object
+           implements class [runtime]System.IEquatable`1<class ABC/ABC/Expr>,
+                      [runtime]System.Collections.IStructuralEquatable,
+                      class [runtime]System.IComparable`1<class ABC/ABC/Expr>,
+                      [runtime]System.IComparable,
+                      [runtime]System.Collections.IStructuralComparable
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                     61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public static class ABC/ABC/Expr NewNum(int32 item) cil managed
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void ABC/ABC/Expr::.ctor(int32)
+        IL_0006:  ret
+      } 
+
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0C 41 42 43 2B 41 42 43 2B 45   
+                                                                                                                                 78 70 72 00 00 )                                  
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 ABC/ABC/Expr::item
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Tag() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  pop
+        IL_0002:  ldc.i4.0
+        IL_0003:  ret
+      } 
+
+      .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+0.8A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public strict virtual instance string ToString() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/ABC/Expr>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(class ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IComparer V_2,
+                 int32 V_3,
+                 int32 V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_002f
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002d
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.0
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.1
+        IL_001a:  ldfld      int32 ABC/ABC/Expr::item
+        IL_001f:  stloc.s    V_4
+        IL_0021:  ldloc.3
+        IL_0022:  ldloc.s    V_4
+        IL_0024:  cgt
+        IL_0026:  ldloc.3
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  clt
+        IL_002b:  sub
+        IL_002c:  ret
+
+        IL_002d:  ldc.i4.1
+        IL_002e:  ret
+
+        IL_002f:  ldarg.1
+        IL_0030:  brfalse.s  IL_0034
+
+        IL_0032:  ldc.i4.m1
+        IL_0033:  ret
+
+        IL_0034:  ldc.i4.0
+        IL_0035:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  unbox.any  ABC/ABC/Expr
+        IL_0007:  callvirt   instance int32 ABC/ABC/Expr::CompareTo(class ABC/ABC/Expr)
+        IL_000c:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance int32  CompareTo(object obj,
+                                        class [runtime]System.Collections.IComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class ABC/ABC/Expr V_2,
+                 class [runtime]System.Collections.IComparer V_3,
+                 int32 V_4,
+                 int32 V_5)
+        IL_0000:  ldarg.1
+        IL_0001:  unbox.any  ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  brfalse.s  IL_003a
+
+        IL_000a:  ldarg.1
+        IL_000b:  unbox.any  ABC/ABC/Expr
+        IL_0010:  brfalse.s  IL_0038
+
+        IL_0012:  ldarg.0
+        IL_0013:  pop
+        IL_0014:  ldarg.0
+        IL_0015:  stloc.1
+        IL_0016:  ldloc.0
+        IL_0017:  stloc.2
+        IL_0018:  ldarg.2
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.1
+        IL_001b:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0020:  stloc.s    V_4
+        IL_0022:  ldloc.2
+        IL_0023:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0028:  stloc.s    V_5
+        IL_002a:  ldloc.s    V_4
+        IL_002c:  ldloc.s    V_5
+        IL_002e:  cgt
+        IL_0030:  ldloc.s    V_4
+        IL_0032:  ldloc.s    V_5
+        IL_0034:  clt
+        IL_0036:  sub
+        IL_0037:  ret
+
+        IL_0038:  ldc.i4.1
+        IL_0039:  ret
+
+        IL_003a:  ldarg.1
+        IL_003b:  unbox.any  ABC/ABC/Expr
+        IL_0040:  brfalse.s  IL_0044
+
+        IL_0042:  ldc.i4.m1
+        IL_0043:  ret
+
+        IL_0044:  ldc.i4.0
+        IL_0045:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IEqualityComparer V_2)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0024
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldarg.0
+        IL_0006:  pop
+        IL_0007:  ldarg.0
+        IL_0008:  stloc.1
+        IL_0009:  ldc.i4.0
+        IL_000a:  stloc.0
+        IL_000b:  ldc.i4     0x9e3779b9
+        IL_0010:  ldarg.1
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  ldloc.0
+        IL_0019:  ldc.i4.6
+        IL_001a:  shl
+        IL_001b:  ldloc.0
+        IL_001c:  ldc.i4.2
+        IL_001d:  shr
+        IL_001e:  add
+        IL_001f:  add
+        IL_0020:  add
+        IL_0021:  stloc.0
+        IL_0022:  ldloc.0
+        IL_0023:  ret
+
+        IL_0024:  ldc.i4.0
+        IL_0025:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 ABC/ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance bool  Equals(object obj,
+                                    class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class ABC/ABC/Expr V_2,
+                 class ABC/ABC/Expr V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0029
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     ABC/ABC/Expr
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0027
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldarg.0
+        IL_0010:  pop
+        IL_0011:  ldarg.0
+        IL_0012:  stloc.2
+        IL_0013:  ldloc.1
+        IL_0014:  stloc.3
+        IL_0015:  ldarg.2
+        IL_0016:  stloc.s    V_4
+        IL_0018:  ldloc.2
+        IL_0019:  ldfld      int32 ABC/ABC/Expr::item
+        IL_001e:  ldloc.3
+        IL_001f:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0024:  ceq
+        IL_0026:  ret
+
+        IL_0027:  ldc.i4.0
+        IL_0028:  ret
+
+        IL_0029:  ldarg.1
+        IL_002a:  ldnull
+        IL_002b:  cgt.un
+        IL_002d:  ldc.i4.0
+        IL_002e:  ceq
+        IL_0030:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(class ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_001d
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_001b
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldloc.0
+        IL_000d:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  ceq
+        IL_001a:  ret
+
+        IL_001b:  ldc.i4.0
+        IL_001c:  ret
+
+        IL_001d:  ldarg.1
+        IL_001e:  ldnull
+        IL_001f:  cgt.un
+        IL_0021:  ldc.i4.0
+        IL_0022:  ceq
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool ABC/ABC/Expr::Equals(class ABC/ABC/Expr)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Tag()
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+        .get instance int32 ABC/ABC/Expr::get_Tag()
+      } 
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 ABC/ABC/Expr::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit MyExn
+           extends [runtime]System.Exception
+           implements [runtime]System.Collections.IStructuralEquatable
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+      .field assembly int32 Data0@
+      .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 ABC/ABC/MyExn::Data0@
+        IL_000d:  ret
+      } 
+
+      .method public specialname rtspecialname instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method family specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  ldarg.2
+        IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                             valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+        IL_0008:  ret
+      } 
+
+      .method public hidebysig specialname instance int32  get_Data0() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 ABC/ABC/MyExn::Data0@
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance string get_Message() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/ABC/MyExn>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/MyExn,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [runtime]System.Collections.IEqualityComparer V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0023
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldc.i4     0x9e3779b9
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldarg.0
+        IL_000d:  castclass  ABC/ABC/MyExn
+        IL_0012:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0017:  ldloc.0
+        IL_0018:  ldc.i4.6
+        IL_0019:  shl
+        IL_001a:  ldloc.0
+        IL_001b:  ldc.i4.2
+        IL_001c:  shr
+        IL_001d:  add
+        IL_001e:  add
+        IL_001f:  add
+        IL_0020:  stloc.0
+        IL_0021:  ldloc.0
+        IL_0022:  ret
+
+        IL_0023:  ldc.i4.0
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 ABC/ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual instance bool 
+              Equals(object obj,
+                     class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1,
+                 object V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_003b
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     [runtime]System.Exception
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0039
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldloc.0
+        IL_0010:  stloc.2
+        IL_0011:  ldloc.2
+        IL_0012:  isinst     ABC/ABC/MyExn
+        IL_0017:  ldnull
+        IL_0018:  cgt.un
+        IL_001a:  brfalse.s  IL_0037
+
+        IL_001c:  ldarg.2
+        IL_001d:  stloc.3
+        IL_001e:  ldarg.0
+        IL_001f:  castclass  ABC/ABC/MyExn
+        IL_0024:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ldloc.1
+        IL_002a:  castclass  ABC/ABC/MyExn
+        IL_002f:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0034:  ceq
+        IL_0036:  ret
+
+        IL_0037:  ldc.i4.0
+        IL_0038:  ret
+
+        IL_0039:  ldc.i4.0
+        IL_003a:  ret
+
+        IL_003b:  ldarg.1
+        IL_003c:  ldnull
+        IL_003d:  cgt.un
+        IL_003f:  ldc.i4.0
+        IL_0040:  ceq
+        IL_0042:  ret
+      } 
+
+      .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (object V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0030
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002e
+
+        IL_0006:  ldarg.1
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  isinst     ABC/ABC/MyExn
+        IL_000e:  ldnull
+        IL_000f:  cgt.un
+        IL_0011:  brfalse.s  IL_002c
+
+        IL_0013:  ldarg.0
+        IL_0014:  castclass  ABC/ABC/MyExn
+        IL_0019:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_001e:  ldarg.1
+        IL_001f:  castclass  ABC/ABC/MyExn
+        IL_0024:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ceq
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+
+        IL_0030:  ldarg.1
+        IL_0031:  ldnull
+        IL_0032:  cgt.un
+        IL_0034:  ldc.i4.0
+        IL_0035:  ceq
+        IL_0037:  ret
+      } 
+
+      .method public hidebysig virtual instance bool Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     [runtime]System.Exception
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool ABC/ABC/MyExn::Equals(class [runtime]System.Exception)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Data0()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+        .get instance int32 ABC/ABC/MyExn::get_Data0()
+      } 
+    } 
+
+    .class auto ansi serializable nested public A
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+      .field assembly string x
+      .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  ldarg.1
+        IL_000a:  stfld      string ABC/ABC/A::x
+        IL_000f:  ret
+      } 
+
+      .method public hidebysig specialname instance string  get_X() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      string ABC/ABC/A::x
+        IL_0006:  ret
+      } 
+
+      .property instance string X()
+      {
+        .get instance string ABC/ABC/A::get_X()
+      } 
+    } 
+
+    .method public static int32  'add'(int32 x,
+                                       int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public specialname static string get_greeting() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  ret
+    } 
+
+    .property string greeting()
+    {
+      .get string ABC/ABC::get_greeting()
+    } 
+  } 
+
+  .method public static int32  'add'(int32 x,
+                                     int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public specialname static string get_greeting() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello"
+    IL_0005:  ret
+  } 
+
+  .property string greeting()
+  {
+    .get string ABC::get_greeting()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$ABC
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+.class private auto ansi serializable sealed System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+       extends [runtime]System.Enum
+{
+  .custom instance void [runtime]System.FlagsAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field public specialname rtspecialname int32 value__
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes All = int32(0xFFFFFFFF)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes None = int32(0x00000000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicParameterlessConstructor = int32(0x00000001)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicConstructors = int32(0x00000003)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicConstructors = int32(0x00000004)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicMethods = int32(0x00000008)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicMethods = int32(0x00000010)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicFields = int32(0x00000020)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicFields = int32(0x00000040)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicNestedTypes = int32(0x00000080)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicNestedTypes = int32(0x00000100)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicProperties = int32(0x00000200)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicProperties = int32(0x00000400)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicEvents = int32(0x00000800)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicEvents = int32(0x00001000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes Interfaces = int32(0x00002000)
+} 
+
+.class private auto ansi beforefieldinit System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute
+       extends [runtime]System.Attribute
+{
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private class [runtime]System.Type Type@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public specialname rtspecialname 
+          instance void  .ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType,
+                               class [runtime]System.Type Type) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Attribute::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_000d:  ldarg.0
+    IL_000e:  ldarg.2
+    IL_000f:  stfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0014:  ret
+  } 
+
+  .method public hidebysig specialname instance class [runtime]System.Type get_Type() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes get_MemberType() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_0006:  ret
+  } 
+
+  .property instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+          MemberType()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_MemberType()
+  } 
+  .property instance class [runtime]System.Type
+          Type()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_Type()
+  } 
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOn.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOn.il.netcore.debug.bsl
new file mode 100644
index 00000000000..2ba585e199a
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOn.il.netcore.debug.bsl
@@ -0,0 +1,1547 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed ABC
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Expr
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class ABC/Expr>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class ABC/Expr>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                         61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field assembly initonly int32 item
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public static class ABC/Expr NewNum(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void ABC/Expr::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+    {
+      .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                              class [runtime]System.Type) = ( 01 00 60 06 00 00 08 41 42 43 2B 45 78 70 72 00   
+                                                                                                                                                     00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 ABC/Expr::item
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Item() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 ABC/Expr::item
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/Expr>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4,
+               class [runtime]System.Collections.IComparer V_5,
+               int32 V_6,
+               int32 V_7)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_003b
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_0039
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.0
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.1
+      IL_001a:  ldfld      int32 ABC/Expr::item
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.2
+      IL_0022:  stloc.s    V_5
+      IL_0024:  ldloc.3
+      IL_0025:  stloc.s    V_6
+      IL_0027:  ldloc.s    V_4
+      IL_0029:  stloc.s    V_7
+      IL_002b:  ldloc.s    V_6
+      IL_002d:  ldloc.s    V_7
+      IL_002f:  cgt
+      IL_0031:  ldloc.s    V_6
+      IL_0033:  ldloc.s    V_7
+      IL_0035:  clt
+      IL_0037:  sub
+      IL_0038:  ret
+
+      IL_0039:  ldc.i4.1
+      IL_003a:  ret
+
+      IL_003b:  ldarg.1
+      IL_003c:  brfalse.s  IL_0040
+
+      IL_003e:  ldc.i4.m1
+      IL_003f:  ret
+
+      IL_0040:  ldc.i4.0
+      IL_0041:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  ABC/Expr
+      IL_0007:  callvirt   instance int32 ABC/Expr::CompareTo(class ABC/Expr)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class ABC/Expr V_2,
+               class [runtime]System.Collections.IComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IComparer V_6,
+               int32 V_7,
+               int32 V_8)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_0045
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  ABC/Expr
+      IL_0010:  brfalse.s  IL_0043
+
+      IL_0012:  ldarg.0
+      IL_0013:  pop
+      IL_0014:  ldarg.0
+      IL_0015:  stloc.1
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  ldarg.2
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.1
+      IL_001b:  ldfld      int32 ABC/Expr::item
+      IL_0020:  stloc.s    V_4
+      IL_0022:  ldloc.2
+      IL_0023:  ldfld      int32 ABC/Expr::item
+      IL_0028:  stloc.s    V_5
+      IL_002a:  ldloc.3
+      IL_002b:  stloc.s    V_6
+      IL_002d:  ldloc.s    V_4
+      IL_002f:  stloc.s    V_7
+      IL_0031:  ldloc.s    V_5
+      IL_0033:  stloc.s    V_8
+      IL_0035:  ldloc.s    V_7
+      IL_0037:  ldloc.s    V_8
+      IL_0039:  cgt
+      IL_003b:  ldloc.s    V_7
+      IL_003d:  ldloc.s    V_8
+      IL_003f:  clt
+      IL_0041:  sub
+      IL_0042:  ret
+
+      IL_0043:  ldc.i4.1
+      IL_0044:  ret
+
+      IL_0045:  ldarg.1
+      IL_0046:  unbox.any  ABC/Expr
+      IL_004b:  brfalse.s  IL_004f
+
+      IL_004d:  ldc.i4.m1
+      IL_004e:  ret
+
+      IL_004f:  ldc.i4.0
+      IL_0050:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class ABC/Expr V_1,
+               class [runtime]System.Collections.IEqualityComparer V_2,
+               int32 V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0029
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldarg.0
+      IL_0008:  stloc.1
+      IL_0009:  ldc.i4.0
+      IL_000a:  stloc.0
+      IL_000b:  ldc.i4     0x9e3779b9
+      IL_0010:  ldarg.1
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.2
+      IL_001a:  stloc.s    V_4
+      IL_001c:  ldloc.3
+      IL_001d:  ldloc.0
+      IL_001e:  ldc.i4.6
+      IL_001f:  shl
+      IL_0020:  ldloc.0
+      IL_0021:  ldc.i4.2
+      IL_0022:  shr
+      IL_0023:  add
+      IL_0024:  add
+      IL_0025:  add
+      IL_0026:  stloc.0
+      IL_0027:  ldloc.0
+      IL_0028:  ret
+
+      IL_0029:  ldc.i4.0
+      IL_002a:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class ABC/Expr V_2,
+               class ABC/Expr V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4,
+               int32 V_5,
+               int32 V_6,
+               class [runtime]System.Collections.IEqualityComparer V_7)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0035
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     ABC/Expr
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0033
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  pop
+      IL_0011:  ldarg.0
+      IL_0012:  stloc.2
+      IL_0013:  ldloc.1
+      IL_0014:  stloc.3
+      IL_0015:  ldarg.2
+      IL_0016:  stloc.s    V_4
+      IL_0018:  ldloc.2
+      IL_0019:  ldfld      int32 ABC/Expr::item
+      IL_001e:  stloc.s    V_5
+      IL_0020:  ldloc.3
+      IL_0021:  ldfld      int32 ABC/Expr::item
+      IL_0026:  stloc.s    V_6
+      IL_0028:  ldloc.s    V_4
+      IL_002a:  stloc.s    V_7
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  ldloc.s    V_6
+      IL_0030:  ceq
+      IL_0032:  ret
+
+      IL_0033:  ldc.i4.0
+      IL_0034:  ret
+
+      IL_0035:  ldarg.1
+      IL_0036:  ldnull
+      IL_0037:  cgt.un
+      IL_0039:  ldc.i4.0
+      IL_003a:  ceq
+      IL_003c:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001d
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001b
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldloc.0
+      IL_000d:  ldfld      int32 ABC/Expr::item
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  ceq
+      IL_001a:  ret
+
+      IL_001b:  ldc.i4.0
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  ldnull
+      IL_001f:  cgt.un
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool ABC/Expr::Equals(class ABC/Expr)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 ABC/Expr::get_Tag()
+    } 
+    .property instance int32 Item()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .get instance int32 ABC/Expr::get_Item()
+    } 
+  } 
+
+  .class auto ansi serializable nested public beforefieldinit MyExn
+         extends [runtime]System.Exception
+         implements [runtime]System.Collections.IStructuralEquatable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+    .field assembly int32 Data0@
+    .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 ABC/MyExn::Data0@
+      IL_000d:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method family specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  ldarg.2
+      IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_Data0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 ABC/MyExn::Data0@
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string get_Message() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/MyExn>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/MyExn,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1,
+               int32 V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0027
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldc.i4     0x9e3779b9
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  castclass  ABC/MyExn
+      IL_0012:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0017:  stloc.2
+      IL_0018:  ldloc.1
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.2
+      IL_001b:  ldloc.0
+      IL_001c:  ldc.i4.6
+      IL_001d:  shl
+      IL_001e:  ldloc.0
+      IL_001f:  ldc.i4.2
+      IL_0020:  shr
+      IL_0021:  add
+      IL_0022:  add
+      IL_0023:  add
+      IL_0024:  stloc.0
+      IL_0025:  ldloc.0
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual instance bool 
+            Equals(object obj,
+                   class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1,
+               object V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IEqualityComparer V_6)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0046
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     [runtime]System.Exception
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0044
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldloc.0
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.2
+      IL_0012:  isinst     ABC/MyExn
+      IL_0017:  ldnull
+      IL_0018:  cgt.un
+      IL_001a:  brfalse.s  IL_0042
+
+      IL_001c:  ldarg.2
+      IL_001d:  stloc.3
+      IL_001e:  ldarg.0
+      IL_001f:  castclass  ABC/MyExn
+      IL_0024:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0029:  stloc.s    V_4
+      IL_002b:  ldloc.1
+      IL_002c:  castclass  ABC/MyExn
+      IL_0031:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0036:  stloc.s    V_5
+      IL_0038:  ldloc.3
+      IL_0039:  stloc.s    V_6
+      IL_003b:  ldloc.s    V_4
+      IL_003d:  ldloc.s    V_5
+      IL_003f:  ceq
+      IL_0041:  ret
+
+      IL_0042:  ldc.i4.0
+      IL_0043:  ret
+
+      IL_0044:  ldc.i4.0
+      IL_0045:  ret
+
+      IL_0046:  ldarg.1
+      IL_0047:  ldnull
+      IL_0048:  cgt.un
+      IL_004a:  ldc.i4.0
+      IL_004b:  ceq
+      IL_004d:  ret
+    } 
+
+    .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0030
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002e
+
+      IL_0006:  ldarg.1
+      IL_0007:  stloc.0
+      IL_0008:  ldloc.0
+      IL_0009:  isinst     ABC/MyExn
+      IL_000e:  ldnull
+      IL_000f:  cgt.un
+      IL_0011:  brfalse.s  IL_002c
+
+      IL_0013:  ldarg.0
+      IL_0014:  castclass  ABC/MyExn
+      IL_0019:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_001e:  ldarg.1
+      IL_001f:  castclass  ABC/MyExn
+      IL_0024:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0029:  ceq
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+
+      IL_0030:  ldarg.1
+      IL_0031:  ldnull
+      IL_0032:  cgt.un
+      IL_0034:  ldc.i4.0
+      IL_0035:  ceq
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual instance bool Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     [runtime]System.Exception
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool ABC/MyExn::Equals(class [runtime]System.Exception)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Data0()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance int32 ABC/MyExn::get_Data0()
+    } 
+  } 
+
+  .class auto ansi serializable nested public A
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly string x
+    .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldarg.1
+      IL_000a:  stfld      string ABC/A::x
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance string  get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string ABC/A::x
+      IL_0006:  ret
+    } 
+
+    .property instance string X()
+    {
+      .get instance string ABC/A::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public ABC
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested public beforefieldinit Expr
+           extends [runtime]System.Object
+           implements class [runtime]System.IEquatable`1<class ABC/ABC/Expr>,
+                      [runtime]System.Collections.IStructuralEquatable,
+                      class [runtime]System.IComparable`1<class ABC/ABC/Expr>,
+                      [runtime]System.IComparable,
+                      [runtime]System.Collections.IStructuralComparable
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                           61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public static class ABC/ABC/Expr NewNum(int32 item) cil managed
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void ABC/ABC/Expr::.ctor(int32)
+        IL_0006:  ret
+      } 
+
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0C 41 42 43 2B 41 42 43 2B 45   
+                                                                                                                                                       78 70 72 00 00 )                                  
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 ABC/ABC/Expr::item
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Tag() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  pop
+        IL_0002:  ldc.i4.0
+        IL_0003:  ret
+      } 
+
+      .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+0.8A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public strict virtual instance string ToString() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/ABC/Expr>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(class ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IComparer V_2,
+                 int32 V_3,
+                 int32 V_4,
+                 class [runtime]System.Collections.IComparer V_5,
+                 int32 V_6,
+                 int32 V_7)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_003b
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_0039
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.0
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.1
+        IL_001a:  ldfld      int32 ABC/ABC/Expr::item
+        IL_001f:  stloc.s    V_4
+        IL_0021:  ldloc.2
+        IL_0022:  stloc.s    V_5
+        IL_0024:  ldloc.3
+        IL_0025:  stloc.s    V_6
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  stloc.s    V_7
+        IL_002b:  ldloc.s    V_6
+        IL_002d:  ldloc.s    V_7
+        IL_002f:  cgt
+        IL_0031:  ldloc.s    V_6
+        IL_0033:  ldloc.s    V_7
+        IL_0035:  clt
+        IL_0037:  sub
+        IL_0038:  ret
+
+        IL_0039:  ldc.i4.1
+        IL_003a:  ret
+
+        IL_003b:  ldarg.1
+        IL_003c:  brfalse.s  IL_0040
+
+        IL_003e:  ldc.i4.m1
+        IL_003f:  ret
+
+        IL_0040:  ldc.i4.0
+        IL_0041:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  unbox.any  ABC/ABC/Expr
+        IL_0007:  callvirt   instance int32 ABC/ABC/Expr::CompareTo(class ABC/ABC/Expr)
+        IL_000c:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance int32  CompareTo(object obj,
+                                        class [runtime]System.Collections.IComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class ABC/ABC/Expr V_2,
+                 class [runtime]System.Collections.IComparer V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class [runtime]System.Collections.IComparer V_6,
+                 int32 V_7,
+                 int32 V_8)
+        IL_0000:  ldarg.1
+        IL_0001:  unbox.any  ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  brfalse.s  IL_0045
+
+        IL_000a:  ldarg.1
+        IL_000b:  unbox.any  ABC/ABC/Expr
+        IL_0010:  brfalse.s  IL_0043
+
+        IL_0012:  ldarg.0
+        IL_0013:  pop
+        IL_0014:  ldarg.0
+        IL_0015:  stloc.1
+        IL_0016:  ldloc.0
+        IL_0017:  stloc.2
+        IL_0018:  ldarg.2
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.1
+        IL_001b:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0020:  stloc.s    V_4
+        IL_0022:  ldloc.2
+        IL_0023:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0028:  stloc.s    V_5
+        IL_002a:  ldloc.3
+        IL_002b:  stloc.s    V_6
+        IL_002d:  ldloc.s    V_4
+        IL_002f:  stloc.s    V_7
+        IL_0031:  ldloc.s    V_5
+        IL_0033:  stloc.s    V_8
+        IL_0035:  ldloc.s    V_7
+        IL_0037:  ldloc.s    V_8
+        IL_0039:  cgt
+        IL_003b:  ldloc.s    V_7
+        IL_003d:  ldloc.s    V_8
+        IL_003f:  clt
+        IL_0041:  sub
+        IL_0042:  ret
+
+        IL_0043:  ldc.i4.1
+        IL_0044:  ret
+
+        IL_0045:  ldarg.1
+        IL_0046:  unbox.any  ABC/ABC/Expr
+        IL_004b:  brfalse.s  IL_004f
+
+        IL_004d:  ldc.i4.m1
+        IL_004e:  ret
+
+        IL_004f:  ldc.i4.0
+        IL_0050:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IEqualityComparer V_2,
+                 int32 V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0029
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldarg.0
+        IL_0006:  pop
+        IL_0007:  ldarg.0
+        IL_0008:  stloc.1
+        IL_0009:  ldc.i4.0
+        IL_000a:  stloc.0
+        IL_000b:  ldc.i4     0x9e3779b9
+        IL_0010:  ldarg.1
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.2
+        IL_001a:  stloc.s    V_4
+        IL_001c:  ldloc.3
+        IL_001d:  ldloc.0
+        IL_001e:  ldc.i4.6
+        IL_001f:  shl
+        IL_0020:  ldloc.0
+        IL_0021:  ldc.i4.2
+        IL_0022:  shr
+        IL_0023:  add
+        IL_0024:  add
+        IL_0025:  add
+        IL_0026:  stloc.0
+        IL_0027:  ldloc.0
+        IL_0028:  ret
+
+        IL_0029:  ldc.i4.0
+        IL_002a:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 ABC/ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance bool  Equals(object obj,
+                                    class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class ABC/ABC/Expr V_2,
+                 class ABC/ABC/Expr V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4,
+                 int32 V_5,
+                 int32 V_6,
+                 class [runtime]System.Collections.IEqualityComparer V_7)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0035
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     ABC/ABC/Expr
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0033
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldarg.0
+        IL_0010:  pop
+        IL_0011:  ldarg.0
+        IL_0012:  stloc.2
+        IL_0013:  ldloc.1
+        IL_0014:  stloc.3
+        IL_0015:  ldarg.2
+        IL_0016:  stloc.s    V_4
+        IL_0018:  ldloc.2
+        IL_0019:  ldfld      int32 ABC/ABC/Expr::item
+        IL_001e:  stloc.s    V_5
+        IL_0020:  ldloc.3
+        IL_0021:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0026:  stloc.s    V_6
+        IL_0028:  ldloc.s    V_4
+        IL_002a:  stloc.s    V_7
+        IL_002c:  ldloc.s    V_5
+        IL_002e:  ldloc.s    V_6
+        IL_0030:  ceq
+        IL_0032:  ret
+
+        IL_0033:  ldc.i4.0
+        IL_0034:  ret
+
+        IL_0035:  ldarg.1
+        IL_0036:  ldnull
+        IL_0037:  cgt.un
+        IL_0039:  ldc.i4.0
+        IL_003a:  ceq
+        IL_003c:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(class ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_001d
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_001b
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldloc.0
+        IL_000d:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  ceq
+        IL_001a:  ret
+
+        IL_001b:  ldc.i4.0
+        IL_001c:  ret
+
+        IL_001d:  ldarg.1
+        IL_001e:  ldnull
+        IL_001f:  cgt.un
+        IL_0021:  ldc.i4.0
+        IL_0022:  ceq
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool ABC/ABC/Expr::Equals(class ABC/ABC/Expr)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Tag()
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+        .get instance int32 ABC/ABC/Expr::get_Tag()
+      } 
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 ABC/ABC/Expr::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit MyExn
+           extends [runtime]System.Exception
+           implements [runtime]System.Collections.IStructuralEquatable
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+      .field assembly int32 Data0@
+      .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 ABC/ABC/MyExn::Data0@
+        IL_000d:  ret
+      } 
+
+      .method public specialname rtspecialname instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method family specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  ldarg.2
+        IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+        IL_0008:  ret
+      } 
+
+      .method public hidebysig specialname instance int32  get_Data0() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 ABC/ABC/MyExn::Data0@
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance string get_Message() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/ABC/MyExn>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/MyExn,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [runtime]System.Collections.IEqualityComparer V_1,
+                 int32 V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0027
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldc.i4     0x9e3779b9
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldarg.0
+        IL_000d:  castclass  ABC/ABC/MyExn
+        IL_0012:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0017:  stloc.2
+        IL_0018:  ldloc.1
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.2
+        IL_001b:  ldloc.0
+        IL_001c:  ldc.i4.6
+        IL_001d:  shl
+        IL_001e:  ldloc.0
+        IL_001f:  ldc.i4.2
+        IL_0020:  shr
+        IL_0021:  add
+        IL_0022:  add
+        IL_0023:  add
+        IL_0024:  stloc.0
+        IL_0025:  ldloc.0
+        IL_0026:  ret
+
+        IL_0027:  ldc.i4.0
+        IL_0028:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 ABC/ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual instance bool 
+              Equals(object obj,
+                     class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1,
+                 object V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class [runtime]System.Collections.IEqualityComparer V_6)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0046
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     [runtime]System.Exception
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0044
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldloc.0
+        IL_0010:  stloc.2
+        IL_0011:  ldloc.2
+        IL_0012:  isinst     ABC/ABC/MyExn
+        IL_0017:  ldnull
+        IL_0018:  cgt.un
+        IL_001a:  brfalse.s  IL_0042
+
+        IL_001c:  ldarg.2
+        IL_001d:  stloc.3
+        IL_001e:  ldarg.0
+        IL_001f:  castclass  ABC/ABC/MyExn
+        IL_0024:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0029:  stloc.s    V_4
+        IL_002b:  ldloc.1
+        IL_002c:  castclass  ABC/ABC/MyExn
+        IL_0031:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0036:  stloc.s    V_5
+        IL_0038:  ldloc.3
+        IL_0039:  stloc.s    V_6
+        IL_003b:  ldloc.s    V_4
+        IL_003d:  ldloc.s    V_5
+        IL_003f:  ceq
+        IL_0041:  ret
+
+        IL_0042:  ldc.i4.0
+        IL_0043:  ret
+
+        IL_0044:  ldc.i4.0
+        IL_0045:  ret
+
+        IL_0046:  ldarg.1
+        IL_0047:  ldnull
+        IL_0048:  cgt.un
+        IL_004a:  ldc.i4.0
+        IL_004b:  ceq
+        IL_004d:  ret
+      } 
+
+      .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (object V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0030
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002e
+
+        IL_0006:  ldarg.1
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  isinst     ABC/ABC/MyExn
+        IL_000e:  ldnull
+        IL_000f:  cgt.un
+        IL_0011:  brfalse.s  IL_002c
+
+        IL_0013:  ldarg.0
+        IL_0014:  castclass  ABC/ABC/MyExn
+        IL_0019:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_001e:  ldarg.1
+        IL_001f:  castclass  ABC/ABC/MyExn
+        IL_0024:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ceq
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+
+        IL_0030:  ldarg.1
+        IL_0031:  ldnull
+        IL_0032:  cgt.un
+        IL_0034:  ldc.i4.0
+        IL_0035:  ceq
+        IL_0037:  ret
+      } 
+
+      .method public hidebysig virtual instance bool Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     [runtime]System.Exception
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool ABC/ABC/MyExn::Equals(class [runtime]System.Exception)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Data0()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+        .get instance int32 ABC/ABC/MyExn::get_Data0()
+      } 
+    } 
+
+    .class auto ansi serializable nested public A
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+      .field assembly string x
+      .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  ldarg.1
+        IL_000a:  stfld      string ABC/ABC/A::x
+        IL_000f:  ret
+      } 
+
+      .method public hidebysig specialname instance string  get_X() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      string ABC/ABC/A::x
+        IL_0006:  ret
+      } 
+
+      .property instance string X()
+      {
+        .get instance string ABC/ABC/A::get_X()
+      } 
+    } 
+
+    .method public static int32  'add'(int32 x,
+                                       int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public specialname static string get_greeting() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  ret
+    } 
+
+    .property string greeting()
+    {
+      .get string ABC/ABC::get_greeting()
+    } 
+  } 
+
+  .method public static int32  'add'(int32 x,
+                                     int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public specialname static string get_greeting() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello"
+    IL_0005:  ret
+  } 
+
+  .property string greeting()
+  {
+    .get string ABC::get_greeting()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$ABC
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOn.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOn.il.netcore.release.bsl
new file mode 100644
index 00000000000..13b2cef620c
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule.fs.RealInternalSignatureOn.il.netcore.release.bsl
@@ -0,0 +1,1451 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed ABC
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Expr
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class ABC/Expr>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class ABC/Expr>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                         61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field assembly initonly int32 item
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public static class ABC/Expr NewNum(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void ABC/Expr::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+    {
+      .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                              class [runtime]System.Type) = ( 01 00 60 06 00 00 08 41 42 43 2B 45 78 70 72 00   
+                                                                                                                                                     00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 ABC/Expr::item
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Item() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 ABC/Expr::item
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/Expr>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_002f
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002d
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.0
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.1
+      IL_001a:  ldfld      int32 ABC/Expr::item
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.3
+      IL_0022:  ldloc.s    V_4
+      IL_0024:  cgt
+      IL_0026:  ldloc.3
+      IL_0027:  ldloc.s    V_4
+      IL_0029:  clt
+      IL_002b:  sub
+      IL_002c:  ret
+
+      IL_002d:  ldc.i4.1
+      IL_002e:  ret
+
+      IL_002f:  ldarg.1
+      IL_0030:  brfalse.s  IL_0034
+
+      IL_0032:  ldc.i4.m1
+      IL_0033:  ret
+
+      IL_0034:  ldc.i4.0
+      IL_0035:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  ABC/Expr
+      IL_0007:  callvirt   instance int32 ABC/Expr::CompareTo(class ABC/Expr)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class ABC/Expr V_2,
+               class [runtime]System.Collections.IComparer V_3,
+               int32 V_4,
+               int32 V_5)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_003a
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  ABC/Expr
+      IL_0010:  brfalse.s  IL_0038
+
+      IL_0012:  ldarg.0
+      IL_0013:  pop
+      IL_0014:  ldarg.0
+      IL_0015:  stloc.1
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  ldarg.2
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.1
+      IL_001b:  ldfld      int32 ABC/Expr::item
+      IL_0020:  stloc.s    V_4
+      IL_0022:  ldloc.2
+      IL_0023:  ldfld      int32 ABC/Expr::item
+      IL_0028:  stloc.s    V_5
+      IL_002a:  ldloc.s    V_4
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  cgt
+      IL_0030:  ldloc.s    V_4
+      IL_0032:  ldloc.s    V_5
+      IL_0034:  clt
+      IL_0036:  sub
+      IL_0037:  ret
+
+      IL_0038:  ldc.i4.1
+      IL_0039:  ret
+
+      IL_003a:  ldarg.1
+      IL_003b:  unbox.any  ABC/Expr
+      IL_0040:  brfalse.s  IL_0044
+
+      IL_0042:  ldc.i4.m1
+      IL_0043:  ret
+
+      IL_0044:  ldc.i4.0
+      IL_0045:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class ABC/Expr V_1,
+               class [runtime]System.Collections.IEqualityComparer V_2)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0024
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldarg.0
+      IL_0008:  stloc.1
+      IL_0009:  ldc.i4.0
+      IL_000a:  stloc.0
+      IL_000b:  ldc.i4     0x9e3779b9
+      IL_0010:  ldarg.1
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  ldloc.0
+      IL_0019:  ldc.i4.6
+      IL_001a:  shl
+      IL_001b:  ldloc.0
+      IL_001c:  ldc.i4.2
+      IL_001d:  shr
+      IL_001e:  add
+      IL_001f:  add
+      IL_0020:  add
+      IL_0021:  stloc.0
+      IL_0022:  ldloc.0
+      IL_0023:  ret
+
+      IL_0024:  ldc.i4.0
+      IL_0025:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class ABC/Expr V_2,
+               class ABC/Expr V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0029
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     ABC/Expr
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0027
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  pop
+      IL_0011:  ldarg.0
+      IL_0012:  stloc.2
+      IL_0013:  ldloc.1
+      IL_0014:  stloc.3
+      IL_0015:  ldarg.2
+      IL_0016:  stloc.s    V_4
+      IL_0018:  ldloc.2
+      IL_0019:  ldfld      int32 ABC/Expr::item
+      IL_001e:  ldloc.3
+      IL_001f:  ldfld      int32 ABC/Expr::item
+      IL_0024:  ceq
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+
+      IL_0029:  ldarg.1
+      IL_002a:  ldnull
+      IL_002b:  cgt.un
+      IL_002d:  ldc.i4.0
+      IL_002e:  ceq
+      IL_0030:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001d
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001b
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldloc.0
+      IL_000d:  ldfld      int32 ABC/Expr::item
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  ceq
+      IL_001a:  ret
+
+      IL_001b:  ldc.i4.0
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  ldnull
+      IL_001f:  cgt.un
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool ABC/Expr::Equals(class ABC/Expr)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 ABC/Expr::get_Tag()
+    } 
+    .property instance int32 Item()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .get instance int32 ABC/Expr::get_Item()
+    } 
+  } 
+
+  .class auto ansi serializable nested public beforefieldinit MyExn
+         extends [runtime]System.Exception
+         implements [runtime]System.Collections.IStructuralEquatable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+    .field assembly int32 Data0@
+    .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 ABC/MyExn::Data0@
+      IL_000d:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method family specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  ldarg.2
+      IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_Data0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 ABC/MyExn::Data0@
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string get_Message() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/MyExn>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/MyExn,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0023
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldc.i4     0x9e3779b9
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  castclass  ABC/MyExn
+      IL_0012:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0017:  ldloc.0
+      IL_0018:  ldc.i4.6
+      IL_0019:  shl
+      IL_001a:  ldloc.0
+      IL_001b:  ldc.i4.2
+      IL_001c:  shr
+      IL_001d:  add
+      IL_001e:  add
+      IL_001f:  add
+      IL_0020:  stloc.0
+      IL_0021:  ldloc.0
+      IL_0022:  ret
+
+      IL_0023:  ldc.i4.0
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual instance bool 
+            Equals(object obj,
+                   class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1,
+               object V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_003b
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     [runtime]System.Exception
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0039
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldloc.0
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.2
+      IL_0012:  isinst     ABC/MyExn
+      IL_0017:  ldnull
+      IL_0018:  cgt.un
+      IL_001a:  brfalse.s  IL_0037
+
+      IL_001c:  ldarg.2
+      IL_001d:  stloc.3
+      IL_001e:  ldarg.0
+      IL_001f:  castclass  ABC/MyExn
+      IL_0024:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0029:  ldloc.1
+      IL_002a:  castclass  ABC/MyExn
+      IL_002f:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0034:  ceq
+      IL_0036:  ret
+
+      IL_0037:  ldc.i4.0
+      IL_0038:  ret
+
+      IL_0039:  ldc.i4.0
+      IL_003a:  ret
+
+      IL_003b:  ldarg.1
+      IL_003c:  ldnull
+      IL_003d:  cgt.un
+      IL_003f:  ldc.i4.0
+      IL_0040:  ceq
+      IL_0042:  ret
+    } 
+
+    .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0030
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002e
+
+      IL_0006:  ldarg.1
+      IL_0007:  stloc.0
+      IL_0008:  ldloc.0
+      IL_0009:  isinst     ABC/MyExn
+      IL_000e:  ldnull
+      IL_000f:  cgt.un
+      IL_0011:  brfalse.s  IL_002c
+
+      IL_0013:  ldarg.0
+      IL_0014:  castclass  ABC/MyExn
+      IL_0019:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_001e:  ldarg.1
+      IL_001f:  castclass  ABC/MyExn
+      IL_0024:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0029:  ceq
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+
+      IL_0030:  ldarg.1
+      IL_0031:  ldnull
+      IL_0032:  cgt.un
+      IL_0034:  ldc.i4.0
+      IL_0035:  ceq
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual instance bool Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     [runtime]System.Exception
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool ABC/MyExn::Equals(class [runtime]System.Exception)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Data0()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance int32 ABC/MyExn::get_Data0()
+    } 
+  } 
+
+  .class auto ansi serializable nested public A
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly string x
+    .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldarg.1
+      IL_000a:  stfld      string ABC/A::x
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance string  get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string ABC/A::x
+      IL_0006:  ret
+    } 
+
+    .property instance string X()
+    {
+      .get instance string ABC/A::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public ABC
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested public beforefieldinit Expr
+           extends [runtime]System.Object
+           implements class [runtime]System.IEquatable`1<class ABC/ABC/Expr>,
+                      [runtime]System.Collections.IStructuralEquatable,
+                      class [runtime]System.IComparable`1<class ABC/ABC/Expr>,
+                      [runtime]System.IComparable,
+                      [runtime]System.Collections.IStructuralComparable
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                           61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public static class ABC/ABC/Expr NewNum(int32 item) cil managed
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void ABC/ABC/Expr::.ctor(int32)
+        IL_0006:  ret
+      } 
+
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0C 41 42 43 2B 41 42 43 2B 45   
+                                                                                                                                                       78 70 72 00 00 )                                  
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 ABC/ABC/Expr::item
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Tag() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  pop
+        IL_0002:  ldc.i4.0
+        IL_0003:  ret
+      } 
+
+      .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+0.8A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public strict virtual instance string ToString() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/ABC/Expr>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(class ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IComparer V_2,
+                 int32 V_3,
+                 int32 V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_002f
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002d
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.0
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.1
+        IL_001a:  ldfld      int32 ABC/ABC/Expr::item
+        IL_001f:  stloc.s    V_4
+        IL_0021:  ldloc.3
+        IL_0022:  ldloc.s    V_4
+        IL_0024:  cgt
+        IL_0026:  ldloc.3
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  clt
+        IL_002b:  sub
+        IL_002c:  ret
+
+        IL_002d:  ldc.i4.1
+        IL_002e:  ret
+
+        IL_002f:  ldarg.1
+        IL_0030:  brfalse.s  IL_0034
+
+        IL_0032:  ldc.i4.m1
+        IL_0033:  ret
+
+        IL_0034:  ldc.i4.0
+        IL_0035:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  unbox.any  ABC/ABC/Expr
+        IL_0007:  callvirt   instance int32 ABC/ABC/Expr::CompareTo(class ABC/ABC/Expr)
+        IL_000c:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance int32  CompareTo(object obj,
+                                        class [runtime]System.Collections.IComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class ABC/ABC/Expr V_2,
+                 class [runtime]System.Collections.IComparer V_3,
+                 int32 V_4,
+                 int32 V_5)
+        IL_0000:  ldarg.1
+        IL_0001:  unbox.any  ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  brfalse.s  IL_003a
+
+        IL_000a:  ldarg.1
+        IL_000b:  unbox.any  ABC/ABC/Expr
+        IL_0010:  brfalse.s  IL_0038
+
+        IL_0012:  ldarg.0
+        IL_0013:  pop
+        IL_0014:  ldarg.0
+        IL_0015:  stloc.1
+        IL_0016:  ldloc.0
+        IL_0017:  stloc.2
+        IL_0018:  ldarg.2
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.1
+        IL_001b:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0020:  stloc.s    V_4
+        IL_0022:  ldloc.2
+        IL_0023:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0028:  stloc.s    V_5
+        IL_002a:  ldloc.s    V_4
+        IL_002c:  ldloc.s    V_5
+        IL_002e:  cgt
+        IL_0030:  ldloc.s    V_4
+        IL_0032:  ldloc.s    V_5
+        IL_0034:  clt
+        IL_0036:  sub
+        IL_0037:  ret
+
+        IL_0038:  ldc.i4.1
+        IL_0039:  ret
+
+        IL_003a:  ldarg.1
+        IL_003b:  unbox.any  ABC/ABC/Expr
+        IL_0040:  brfalse.s  IL_0044
+
+        IL_0042:  ldc.i4.m1
+        IL_0043:  ret
+
+        IL_0044:  ldc.i4.0
+        IL_0045:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IEqualityComparer V_2)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0024
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldarg.0
+        IL_0006:  pop
+        IL_0007:  ldarg.0
+        IL_0008:  stloc.1
+        IL_0009:  ldc.i4.0
+        IL_000a:  stloc.0
+        IL_000b:  ldc.i4     0x9e3779b9
+        IL_0010:  ldarg.1
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  ldloc.0
+        IL_0019:  ldc.i4.6
+        IL_001a:  shl
+        IL_001b:  ldloc.0
+        IL_001c:  ldc.i4.2
+        IL_001d:  shr
+        IL_001e:  add
+        IL_001f:  add
+        IL_0020:  add
+        IL_0021:  stloc.0
+        IL_0022:  ldloc.0
+        IL_0023:  ret
+
+        IL_0024:  ldc.i4.0
+        IL_0025:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 ABC/ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance bool  Equals(object obj,
+                                    class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class ABC/ABC/Expr V_2,
+                 class ABC/ABC/Expr V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0029
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     ABC/ABC/Expr
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0027
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldarg.0
+        IL_0010:  pop
+        IL_0011:  ldarg.0
+        IL_0012:  stloc.2
+        IL_0013:  ldloc.1
+        IL_0014:  stloc.3
+        IL_0015:  ldarg.2
+        IL_0016:  stloc.s    V_4
+        IL_0018:  ldloc.2
+        IL_0019:  ldfld      int32 ABC/ABC/Expr::item
+        IL_001e:  ldloc.3
+        IL_001f:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0024:  ceq
+        IL_0026:  ret
+
+        IL_0027:  ldc.i4.0
+        IL_0028:  ret
+
+        IL_0029:  ldarg.1
+        IL_002a:  ldnull
+        IL_002b:  cgt.un
+        IL_002d:  ldc.i4.0
+        IL_002e:  ceq
+        IL_0030:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(class ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_001d
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_001b
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldloc.0
+        IL_000d:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  ceq
+        IL_001a:  ret
+
+        IL_001b:  ldc.i4.0
+        IL_001c:  ret
+
+        IL_001d:  ldarg.1
+        IL_001e:  ldnull
+        IL_001f:  cgt.un
+        IL_0021:  ldc.i4.0
+        IL_0022:  ceq
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool ABC/ABC/Expr::Equals(class ABC/ABC/Expr)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Tag()
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+        .get instance int32 ABC/ABC/Expr::get_Tag()
+      } 
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 ABC/ABC/Expr::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit MyExn
+           extends [runtime]System.Exception
+           implements [runtime]System.Collections.IStructuralEquatable
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+      .field assembly int32 Data0@
+      .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 ABC/ABC/MyExn::Data0@
+        IL_000d:  ret
+      } 
+
+      .method public specialname rtspecialname instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method family specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  ldarg.2
+        IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+        IL_0008:  ret
+      } 
+
+      .method public hidebysig specialname instance int32  get_Data0() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 ABC/ABC/MyExn::Data0@
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance string get_Message() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/ABC/MyExn>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/MyExn,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [runtime]System.Collections.IEqualityComparer V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0023
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldc.i4     0x9e3779b9
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldarg.0
+        IL_000d:  castclass  ABC/ABC/MyExn
+        IL_0012:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0017:  ldloc.0
+        IL_0018:  ldc.i4.6
+        IL_0019:  shl
+        IL_001a:  ldloc.0
+        IL_001b:  ldc.i4.2
+        IL_001c:  shr
+        IL_001d:  add
+        IL_001e:  add
+        IL_001f:  add
+        IL_0020:  stloc.0
+        IL_0021:  ldloc.0
+        IL_0022:  ret
+
+        IL_0023:  ldc.i4.0
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 ABC/ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual instance bool 
+              Equals(object obj,
+                     class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1,
+                 object V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_003b
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     [runtime]System.Exception
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0039
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldloc.0
+        IL_0010:  stloc.2
+        IL_0011:  ldloc.2
+        IL_0012:  isinst     ABC/ABC/MyExn
+        IL_0017:  ldnull
+        IL_0018:  cgt.un
+        IL_001a:  brfalse.s  IL_0037
+
+        IL_001c:  ldarg.2
+        IL_001d:  stloc.3
+        IL_001e:  ldarg.0
+        IL_001f:  castclass  ABC/ABC/MyExn
+        IL_0024:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ldloc.1
+        IL_002a:  castclass  ABC/ABC/MyExn
+        IL_002f:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0034:  ceq
+        IL_0036:  ret
+
+        IL_0037:  ldc.i4.0
+        IL_0038:  ret
+
+        IL_0039:  ldc.i4.0
+        IL_003a:  ret
+
+        IL_003b:  ldarg.1
+        IL_003c:  ldnull
+        IL_003d:  cgt.un
+        IL_003f:  ldc.i4.0
+        IL_0040:  ceq
+        IL_0042:  ret
+      } 
+
+      .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (object V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0030
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002e
+
+        IL_0006:  ldarg.1
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  isinst     ABC/ABC/MyExn
+        IL_000e:  ldnull
+        IL_000f:  cgt.un
+        IL_0011:  brfalse.s  IL_002c
+
+        IL_0013:  ldarg.0
+        IL_0014:  castclass  ABC/ABC/MyExn
+        IL_0019:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_001e:  ldarg.1
+        IL_001f:  castclass  ABC/ABC/MyExn
+        IL_0024:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ceq
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+
+        IL_0030:  ldarg.1
+        IL_0031:  ldnull
+        IL_0032:  cgt.un
+        IL_0034:  ldc.i4.0
+        IL_0035:  ceq
+        IL_0037:  ret
+      } 
+
+      .method public hidebysig virtual instance bool Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     [runtime]System.Exception
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool ABC/ABC/MyExn::Equals(class [runtime]System.Exception)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Data0()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+        .get instance int32 ABC/ABC/MyExn::get_Data0()
+      } 
+    } 
+
+    .class auto ansi serializable nested public A
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+      .field assembly string x
+      .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  ldarg.1
+        IL_000a:  stfld      string ABC/ABC/A::x
+        IL_000f:  ret
+      } 
+
+      .method public hidebysig specialname instance string  get_X() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      string ABC/ABC/A::x
+        IL_0006:  ret
+      } 
+
+      .property instance string X()
+      {
+        .get instance string ABC/ABC/A::get_X()
+      } 
+    } 
+
+    .method public static int32  'add'(int32 x,
+                                       int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public specialname static string get_greeting() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  ret
+    } 
+
+    .property string greeting()
+    {
+      .get string ABC/ABC::get_greeting()
+    } 
+  } 
+
+  .method public static int32  'add'(int32 x,
+                                     int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public specialname static string get_greeting() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello"
+    IL_0005:  ret
+  } 
+
+  .property string greeting()
+  {
+    .get string ABC::get_greeting()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$ABC
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOff.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOff.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOff.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOff.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOff.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOff.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOff.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOff.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOn.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOn.il.net472.debug.bsl
new file mode 100644
index 00000000000..0f51d627320
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOn.il.net472.debug.bsl
@@ -0,0 +1,1613 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed ABC
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Expr
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class ABC/Expr>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class ABC/Expr>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                   61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field assembly initonly int32 item
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public static class ABC/Expr NewNum(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void ABC/Expr::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+    {
+      .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                              class [runtime]System.Type) = ( 01 00 60 06 00 00 08 41 42 43 2B 45 78 70 72 00   
+                                                                                                                               00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 ABC/Expr::item
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Item() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 ABC/Expr::item
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/Expr>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4,
+               class [runtime]System.Collections.IComparer V_5,
+               int32 V_6,
+               int32 V_7)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_003b
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_0039
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.0
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.1
+      IL_001a:  ldfld      int32 ABC/Expr::item
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.2
+      IL_0022:  stloc.s    V_5
+      IL_0024:  ldloc.3
+      IL_0025:  stloc.s    V_6
+      IL_0027:  ldloc.s    V_4
+      IL_0029:  stloc.s    V_7
+      IL_002b:  ldloc.s    V_6
+      IL_002d:  ldloc.s    V_7
+      IL_002f:  cgt
+      IL_0031:  ldloc.s    V_6
+      IL_0033:  ldloc.s    V_7
+      IL_0035:  clt
+      IL_0037:  sub
+      IL_0038:  ret
+
+      IL_0039:  ldc.i4.1
+      IL_003a:  ret
+
+      IL_003b:  ldarg.1
+      IL_003c:  brfalse.s  IL_0040
+
+      IL_003e:  ldc.i4.m1
+      IL_003f:  ret
+
+      IL_0040:  ldc.i4.0
+      IL_0041:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  ABC/Expr
+      IL_0007:  callvirt   instance int32 ABC/Expr::CompareTo(class ABC/Expr)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class ABC/Expr V_2,
+               class [runtime]System.Collections.IComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IComparer V_6,
+               int32 V_7,
+               int32 V_8)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_0045
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  ABC/Expr
+      IL_0010:  brfalse.s  IL_0043
+
+      IL_0012:  ldarg.0
+      IL_0013:  pop
+      IL_0014:  ldarg.0
+      IL_0015:  stloc.1
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  ldarg.2
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.1
+      IL_001b:  ldfld      int32 ABC/Expr::item
+      IL_0020:  stloc.s    V_4
+      IL_0022:  ldloc.2
+      IL_0023:  ldfld      int32 ABC/Expr::item
+      IL_0028:  stloc.s    V_5
+      IL_002a:  ldloc.3
+      IL_002b:  stloc.s    V_6
+      IL_002d:  ldloc.s    V_4
+      IL_002f:  stloc.s    V_7
+      IL_0031:  ldloc.s    V_5
+      IL_0033:  stloc.s    V_8
+      IL_0035:  ldloc.s    V_7
+      IL_0037:  ldloc.s    V_8
+      IL_0039:  cgt
+      IL_003b:  ldloc.s    V_7
+      IL_003d:  ldloc.s    V_8
+      IL_003f:  clt
+      IL_0041:  sub
+      IL_0042:  ret
+
+      IL_0043:  ldc.i4.1
+      IL_0044:  ret
+
+      IL_0045:  ldarg.1
+      IL_0046:  unbox.any  ABC/Expr
+      IL_004b:  brfalse.s  IL_004f
+
+      IL_004d:  ldc.i4.m1
+      IL_004e:  ret
+
+      IL_004f:  ldc.i4.0
+      IL_0050:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class ABC/Expr V_1,
+               class [runtime]System.Collections.IEqualityComparer V_2,
+               int32 V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0029
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldarg.0
+      IL_0008:  stloc.1
+      IL_0009:  ldc.i4.0
+      IL_000a:  stloc.0
+      IL_000b:  ldc.i4     0x9e3779b9
+      IL_0010:  ldarg.1
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.2
+      IL_001a:  stloc.s    V_4
+      IL_001c:  ldloc.3
+      IL_001d:  ldloc.0
+      IL_001e:  ldc.i4.6
+      IL_001f:  shl
+      IL_0020:  ldloc.0
+      IL_0021:  ldc.i4.2
+      IL_0022:  shr
+      IL_0023:  add
+      IL_0024:  add
+      IL_0025:  add
+      IL_0026:  stloc.0
+      IL_0027:  ldloc.0
+      IL_0028:  ret
+
+      IL_0029:  ldc.i4.0
+      IL_002a:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class ABC/Expr V_2,
+               class ABC/Expr V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4,
+               int32 V_5,
+               int32 V_6,
+               class [runtime]System.Collections.IEqualityComparer V_7)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0035
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     ABC/Expr
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0033
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  pop
+      IL_0011:  ldarg.0
+      IL_0012:  stloc.2
+      IL_0013:  ldloc.1
+      IL_0014:  stloc.3
+      IL_0015:  ldarg.2
+      IL_0016:  stloc.s    V_4
+      IL_0018:  ldloc.2
+      IL_0019:  ldfld      int32 ABC/Expr::item
+      IL_001e:  stloc.s    V_5
+      IL_0020:  ldloc.3
+      IL_0021:  ldfld      int32 ABC/Expr::item
+      IL_0026:  stloc.s    V_6
+      IL_0028:  ldloc.s    V_4
+      IL_002a:  stloc.s    V_7
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  ldloc.s    V_6
+      IL_0030:  ceq
+      IL_0032:  ret
+
+      IL_0033:  ldc.i4.0
+      IL_0034:  ret
+
+      IL_0035:  ldarg.1
+      IL_0036:  ldnull
+      IL_0037:  cgt.un
+      IL_0039:  ldc.i4.0
+      IL_003a:  ceq
+      IL_003c:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001d
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001b
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldloc.0
+      IL_000d:  ldfld      int32 ABC/Expr::item
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  ceq
+      IL_001a:  ret
+
+      IL_001b:  ldc.i4.0
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  ldnull
+      IL_001f:  cgt.un
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool ABC/Expr::Equals(class ABC/Expr)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 ABC/Expr::get_Tag()
+    } 
+    .property instance int32 Item()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .get instance int32 ABC/Expr::get_Item()
+    } 
+  } 
+
+  .class auto ansi serializable nested public beforefieldinit MyExn
+         extends [runtime]System.Exception
+         implements [runtime]System.Collections.IStructuralEquatable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+    .field assembly int32 Data0@
+    .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 ABC/MyExn::Data0@
+      IL_000d:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method family specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  ldarg.2
+      IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                           valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_Data0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 ABC/MyExn::Data0@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1,
+               int32 V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0027
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldc.i4     0x9e3779b9
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  castclass  ABC/MyExn
+      IL_0012:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0017:  stloc.2
+      IL_0018:  ldloc.1
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.2
+      IL_001b:  ldloc.0
+      IL_001c:  ldc.i4.6
+      IL_001d:  shl
+      IL_001e:  ldloc.0
+      IL_001f:  ldc.i4.2
+      IL_0020:  shr
+      IL_0021:  add
+      IL_0022:  add
+      IL_0023:  add
+      IL_0024:  stloc.0
+      IL_0025:  ldloc.0
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual instance bool 
+            Equals(object obj,
+                   class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1,
+               object V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IEqualityComparer V_6)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0046
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     [runtime]System.Exception
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0044
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldloc.0
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.2
+      IL_0012:  isinst     ABC/MyExn
+      IL_0017:  ldnull
+      IL_0018:  cgt.un
+      IL_001a:  brfalse.s  IL_0042
+
+      IL_001c:  ldarg.2
+      IL_001d:  stloc.3
+      IL_001e:  ldarg.0
+      IL_001f:  castclass  ABC/MyExn
+      IL_0024:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0029:  stloc.s    V_4
+      IL_002b:  ldloc.1
+      IL_002c:  castclass  ABC/MyExn
+      IL_0031:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0036:  stloc.s    V_5
+      IL_0038:  ldloc.3
+      IL_0039:  stloc.s    V_6
+      IL_003b:  ldloc.s    V_4
+      IL_003d:  ldloc.s    V_5
+      IL_003f:  ceq
+      IL_0041:  ret
+
+      IL_0042:  ldc.i4.0
+      IL_0043:  ret
+
+      IL_0044:  ldc.i4.0
+      IL_0045:  ret
+
+      IL_0046:  ldarg.1
+      IL_0047:  ldnull
+      IL_0048:  cgt.un
+      IL_004a:  ldc.i4.0
+      IL_004b:  ceq
+      IL_004d:  ret
+    } 
+
+    .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0030
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002e
+
+      IL_0006:  ldarg.1
+      IL_0007:  stloc.0
+      IL_0008:  ldloc.0
+      IL_0009:  isinst     ABC/MyExn
+      IL_000e:  ldnull
+      IL_000f:  cgt.un
+      IL_0011:  brfalse.s  IL_002c
+
+      IL_0013:  ldarg.0
+      IL_0014:  castclass  ABC/MyExn
+      IL_0019:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_001e:  ldarg.1
+      IL_001f:  castclass  ABC/MyExn
+      IL_0024:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0029:  ceq
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+
+      IL_0030:  ldarg.1
+      IL_0031:  ldnull
+      IL_0032:  cgt.un
+      IL_0034:  ldc.i4.0
+      IL_0035:  ceq
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual instance bool Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     [runtime]System.Exception
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool ABC/MyExn::Equals(class [runtime]System.Exception)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Data0()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance int32 ABC/MyExn::get_Data0()
+    } 
+  } 
+
+  .class auto ansi serializable nested public A
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly string x
+    .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldarg.1
+      IL_000a:  stfld      string ABC/A::x
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance string  get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string ABC/A::x
+      IL_0006:  ret
+    } 
+
+    .property instance string X()
+    {
+      .get instance string ABC/A::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public ABC
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested public beforefieldinit Expr
+           extends [runtime]System.Object
+           implements class [runtime]System.IEquatable`1<class ABC/ABC/Expr>,
+                      [runtime]System.Collections.IStructuralEquatable,
+                      class [runtime]System.IComparable`1<class ABC/ABC/Expr>,
+                      [runtime]System.IComparable,
+                      [runtime]System.Collections.IStructuralComparable
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                     61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public static class ABC/ABC/Expr NewNum(int32 item) cil managed
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void ABC/ABC/Expr::.ctor(int32)
+        IL_0006:  ret
+      } 
+
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0C 41 42 43 2B 41 42 43 2B 45   
+                                                                                                                                 78 70 72 00 00 )                                  
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 ABC/ABC/Expr::item
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Tag() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  pop
+        IL_0002:  ldc.i4.0
+        IL_0003:  ret
+      } 
+
+      .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+0.8A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public strict virtual instance string ToString() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/ABC/Expr>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(class ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IComparer V_2,
+                 int32 V_3,
+                 int32 V_4,
+                 class [runtime]System.Collections.IComparer V_5,
+                 int32 V_6,
+                 int32 V_7)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_003b
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_0039
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.0
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.1
+        IL_001a:  ldfld      int32 ABC/ABC/Expr::item
+        IL_001f:  stloc.s    V_4
+        IL_0021:  ldloc.2
+        IL_0022:  stloc.s    V_5
+        IL_0024:  ldloc.3
+        IL_0025:  stloc.s    V_6
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  stloc.s    V_7
+        IL_002b:  ldloc.s    V_6
+        IL_002d:  ldloc.s    V_7
+        IL_002f:  cgt
+        IL_0031:  ldloc.s    V_6
+        IL_0033:  ldloc.s    V_7
+        IL_0035:  clt
+        IL_0037:  sub
+        IL_0038:  ret
+
+        IL_0039:  ldc.i4.1
+        IL_003a:  ret
+
+        IL_003b:  ldarg.1
+        IL_003c:  brfalse.s  IL_0040
+
+        IL_003e:  ldc.i4.m1
+        IL_003f:  ret
+
+        IL_0040:  ldc.i4.0
+        IL_0041:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  unbox.any  ABC/ABC/Expr
+        IL_0007:  callvirt   instance int32 ABC/ABC/Expr::CompareTo(class ABC/ABC/Expr)
+        IL_000c:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance int32  CompareTo(object obj,
+                                        class [runtime]System.Collections.IComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class ABC/ABC/Expr V_2,
+                 class [runtime]System.Collections.IComparer V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class [runtime]System.Collections.IComparer V_6,
+                 int32 V_7,
+                 int32 V_8)
+        IL_0000:  ldarg.1
+        IL_0001:  unbox.any  ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  brfalse.s  IL_0045
+
+        IL_000a:  ldarg.1
+        IL_000b:  unbox.any  ABC/ABC/Expr
+        IL_0010:  brfalse.s  IL_0043
+
+        IL_0012:  ldarg.0
+        IL_0013:  pop
+        IL_0014:  ldarg.0
+        IL_0015:  stloc.1
+        IL_0016:  ldloc.0
+        IL_0017:  stloc.2
+        IL_0018:  ldarg.2
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.1
+        IL_001b:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0020:  stloc.s    V_4
+        IL_0022:  ldloc.2
+        IL_0023:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0028:  stloc.s    V_5
+        IL_002a:  ldloc.3
+        IL_002b:  stloc.s    V_6
+        IL_002d:  ldloc.s    V_4
+        IL_002f:  stloc.s    V_7
+        IL_0031:  ldloc.s    V_5
+        IL_0033:  stloc.s    V_8
+        IL_0035:  ldloc.s    V_7
+        IL_0037:  ldloc.s    V_8
+        IL_0039:  cgt
+        IL_003b:  ldloc.s    V_7
+        IL_003d:  ldloc.s    V_8
+        IL_003f:  clt
+        IL_0041:  sub
+        IL_0042:  ret
+
+        IL_0043:  ldc.i4.1
+        IL_0044:  ret
+
+        IL_0045:  ldarg.1
+        IL_0046:  unbox.any  ABC/ABC/Expr
+        IL_004b:  brfalse.s  IL_004f
+
+        IL_004d:  ldc.i4.m1
+        IL_004e:  ret
+
+        IL_004f:  ldc.i4.0
+        IL_0050:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IEqualityComparer V_2,
+                 int32 V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0029
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldarg.0
+        IL_0006:  pop
+        IL_0007:  ldarg.0
+        IL_0008:  stloc.1
+        IL_0009:  ldc.i4.0
+        IL_000a:  stloc.0
+        IL_000b:  ldc.i4     0x9e3779b9
+        IL_0010:  ldarg.1
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.2
+        IL_001a:  stloc.s    V_4
+        IL_001c:  ldloc.3
+        IL_001d:  ldloc.0
+        IL_001e:  ldc.i4.6
+        IL_001f:  shl
+        IL_0020:  ldloc.0
+        IL_0021:  ldc.i4.2
+        IL_0022:  shr
+        IL_0023:  add
+        IL_0024:  add
+        IL_0025:  add
+        IL_0026:  stloc.0
+        IL_0027:  ldloc.0
+        IL_0028:  ret
+
+        IL_0029:  ldc.i4.0
+        IL_002a:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 ABC/ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance bool  Equals(object obj,
+                                    class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class ABC/ABC/Expr V_2,
+                 class ABC/ABC/Expr V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4,
+                 int32 V_5,
+                 int32 V_6,
+                 class [runtime]System.Collections.IEqualityComparer V_7)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0035
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     ABC/ABC/Expr
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0033
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldarg.0
+        IL_0010:  pop
+        IL_0011:  ldarg.0
+        IL_0012:  stloc.2
+        IL_0013:  ldloc.1
+        IL_0014:  stloc.3
+        IL_0015:  ldarg.2
+        IL_0016:  stloc.s    V_4
+        IL_0018:  ldloc.2
+        IL_0019:  ldfld      int32 ABC/ABC/Expr::item
+        IL_001e:  stloc.s    V_5
+        IL_0020:  ldloc.3
+        IL_0021:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0026:  stloc.s    V_6
+        IL_0028:  ldloc.s    V_4
+        IL_002a:  stloc.s    V_7
+        IL_002c:  ldloc.s    V_5
+        IL_002e:  ldloc.s    V_6
+        IL_0030:  ceq
+        IL_0032:  ret
+
+        IL_0033:  ldc.i4.0
+        IL_0034:  ret
+
+        IL_0035:  ldarg.1
+        IL_0036:  ldnull
+        IL_0037:  cgt.un
+        IL_0039:  ldc.i4.0
+        IL_003a:  ceq
+        IL_003c:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(class ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_001d
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_001b
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldloc.0
+        IL_000d:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  ceq
+        IL_001a:  ret
+
+        IL_001b:  ldc.i4.0
+        IL_001c:  ret
+
+        IL_001d:  ldarg.1
+        IL_001e:  ldnull
+        IL_001f:  cgt.un
+        IL_0021:  ldc.i4.0
+        IL_0022:  ceq
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool ABC/ABC/Expr::Equals(class ABC/ABC/Expr)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Tag()
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+        .get instance int32 ABC/ABC/Expr::get_Tag()
+      } 
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 ABC/ABC/Expr::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit MyExn
+           extends [runtime]System.Exception
+           implements [runtime]System.Collections.IStructuralEquatable
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+      .field assembly int32 Data0@
+      .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 ABC/ABC/MyExn::Data0@
+        IL_000d:  ret
+      } 
+
+      .method public specialname rtspecialname instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method family specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  ldarg.2
+        IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                             valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+        IL_0008:  ret
+      } 
+
+      .method public hidebysig specialname instance int32  get_Data0() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 ABC/ABC/MyExn::Data0@
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [runtime]System.Collections.IEqualityComparer V_1,
+                 int32 V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0027
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldc.i4     0x9e3779b9
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldarg.0
+        IL_000d:  castclass  ABC/ABC/MyExn
+        IL_0012:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0017:  stloc.2
+        IL_0018:  ldloc.1
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.2
+        IL_001b:  ldloc.0
+        IL_001c:  ldc.i4.6
+        IL_001d:  shl
+        IL_001e:  ldloc.0
+        IL_001f:  ldc.i4.2
+        IL_0020:  shr
+        IL_0021:  add
+        IL_0022:  add
+        IL_0023:  add
+        IL_0024:  stloc.0
+        IL_0025:  ldloc.0
+        IL_0026:  ret
+
+        IL_0027:  ldc.i4.0
+        IL_0028:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 ABC/ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual instance bool 
+              Equals(object obj,
+                     class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1,
+                 object V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class [runtime]System.Collections.IEqualityComparer V_6)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0046
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     [runtime]System.Exception
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0044
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldloc.0
+        IL_0010:  stloc.2
+        IL_0011:  ldloc.2
+        IL_0012:  isinst     ABC/ABC/MyExn
+        IL_0017:  ldnull
+        IL_0018:  cgt.un
+        IL_001a:  brfalse.s  IL_0042
+
+        IL_001c:  ldarg.2
+        IL_001d:  stloc.3
+        IL_001e:  ldarg.0
+        IL_001f:  castclass  ABC/ABC/MyExn
+        IL_0024:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0029:  stloc.s    V_4
+        IL_002b:  ldloc.1
+        IL_002c:  castclass  ABC/ABC/MyExn
+        IL_0031:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0036:  stloc.s    V_5
+        IL_0038:  ldloc.3
+        IL_0039:  stloc.s    V_6
+        IL_003b:  ldloc.s    V_4
+        IL_003d:  ldloc.s    V_5
+        IL_003f:  ceq
+        IL_0041:  ret
+
+        IL_0042:  ldc.i4.0
+        IL_0043:  ret
+
+        IL_0044:  ldc.i4.0
+        IL_0045:  ret
+
+        IL_0046:  ldarg.1
+        IL_0047:  ldnull
+        IL_0048:  cgt.un
+        IL_004a:  ldc.i4.0
+        IL_004b:  ceq
+        IL_004d:  ret
+      } 
+
+      .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (object V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0030
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002e
+
+        IL_0006:  ldarg.1
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  isinst     ABC/ABC/MyExn
+        IL_000e:  ldnull
+        IL_000f:  cgt.un
+        IL_0011:  brfalse.s  IL_002c
+
+        IL_0013:  ldarg.0
+        IL_0014:  castclass  ABC/ABC/MyExn
+        IL_0019:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_001e:  ldarg.1
+        IL_001f:  castclass  ABC/ABC/MyExn
+        IL_0024:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ceq
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+
+        IL_0030:  ldarg.1
+        IL_0031:  ldnull
+        IL_0032:  cgt.un
+        IL_0034:  ldc.i4.0
+        IL_0035:  ceq
+        IL_0037:  ret
+      } 
+
+      .method public hidebysig virtual instance bool Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     [runtime]System.Exception
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool ABC/ABC/MyExn::Equals(class [runtime]System.Exception)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Data0()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+        .get instance int32 ABC/ABC/MyExn::get_Data0()
+      } 
+    } 
+
+    .class auto ansi serializable nested public A
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+      .field assembly string x
+      .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  ldarg.1
+        IL_000a:  stfld      string ABC/ABC/A::x
+        IL_000f:  ret
+      } 
+
+      .method public hidebysig specialname instance string  get_X() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      string ABC/ABC/A::x
+        IL_0006:  ret
+      } 
+
+      .property instance string X()
+      {
+        .get instance string ABC/ABC/A::get_X()
+      } 
+    } 
+
+    .method public static int32  'add'(int32 x,
+                                       int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public specialname static string get_greeting() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  ret
+    } 
+
+    .property string greeting()
+    {
+      .get string ABC/ABC::get_greeting()
+    } 
+  } 
+
+  .method public static int32  'add'(int32 x,
+                                     int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public specialname static string get_greeting() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello"
+    IL_0005:  ret
+  } 
+
+  .property string greeting()
+  {
+    .get string ABC::get_greeting()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$ABC
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+.class private auto ansi serializable sealed System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+       extends [runtime]System.Enum
+{
+  .custom instance void [runtime]System.FlagsAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field public specialname rtspecialname int32 value__
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes All = int32(0xFFFFFFFF)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes None = int32(0x00000000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicParameterlessConstructor = int32(0x00000001)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicConstructors = int32(0x00000003)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicConstructors = int32(0x00000004)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicMethods = int32(0x00000008)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicMethods = int32(0x00000010)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicFields = int32(0x00000020)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicFields = int32(0x00000040)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicNestedTypes = int32(0x00000080)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicNestedTypes = int32(0x00000100)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicProperties = int32(0x00000200)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicProperties = int32(0x00000400)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicEvents = int32(0x00000800)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicEvents = int32(0x00001000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes Interfaces = int32(0x00002000)
+} 
+
+.class private auto ansi beforefieldinit System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute
+       extends [runtime]System.Attribute
+{
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private class [runtime]System.Type Type@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public specialname rtspecialname 
+          instance void  .ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType,
+                               class [runtime]System.Type Type) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Attribute::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_000d:  ldarg.0
+    IL_000e:  ldarg.2
+    IL_000f:  stfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0014:  ret
+  } 
+
+  .method public hidebysig specialname instance class [runtime]System.Type get_Type() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes get_MemberType() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_0006:  ret
+  } 
+
+  .property instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+          MemberType()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_MemberType()
+  } 
+  .property instance class [runtime]System.Type
+          Type()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_Type()
+  } 
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOn.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOn.il.net472.release.bsl
new file mode 100644
index 00000000000..26beffa3381
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOn.il.net472.release.bsl
@@ -0,0 +1,1517 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed ABC
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Expr
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class ABC/Expr>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class ABC/Expr>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                   61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field assembly initonly int32 item
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public static class ABC/Expr NewNum(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void ABC/Expr::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+    {
+      .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                              class [runtime]System.Type) = ( 01 00 60 06 00 00 08 41 42 43 2B 45 78 70 72 00   
+                                                                                                                               00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 ABC/Expr::item
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Item() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 ABC/Expr::item
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/Expr>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_002f
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002d
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.0
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.1
+      IL_001a:  ldfld      int32 ABC/Expr::item
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.3
+      IL_0022:  ldloc.s    V_4
+      IL_0024:  cgt
+      IL_0026:  ldloc.3
+      IL_0027:  ldloc.s    V_4
+      IL_0029:  clt
+      IL_002b:  sub
+      IL_002c:  ret
+
+      IL_002d:  ldc.i4.1
+      IL_002e:  ret
+
+      IL_002f:  ldarg.1
+      IL_0030:  brfalse.s  IL_0034
+
+      IL_0032:  ldc.i4.m1
+      IL_0033:  ret
+
+      IL_0034:  ldc.i4.0
+      IL_0035:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  ABC/Expr
+      IL_0007:  callvirt   instance int32 ABC/Expr::CompareTo(class ABC/Expr)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class ABC/Expr V_2,
+               class [runtime]System.Collections.IComparer V_3,
+               int32 V_4,
+               int32 V_5)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_003a
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  ABC/Expr
+      IL_0010:  brfalse.s  IL_0038
+
+      IL_0012:  ldarg.0
+      IL_0013:  pop
+      IL_0014:  ldarg.0
+      IL_0015:  stloc.1
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  ldarg.2
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.1
+      IL_001b:  ldfld      int32 ABC/Expr::item
+      IL_0020:  stloc.s    V_4
+      IL_0022:  ldloc.2
+      IL_0023:  ldfld      int32 ABC/Expr::item
+      IL_0028:  stloc.s    V_5
+      IL_002a:  ldloc.s    V_4
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  cgt
+      IL_0030:  ldloc.s    V_4
+      IL_0032:  ldloc.s    V_5
+      IL_0034:  clt
+      IL_0036:  sub
+      IL_0037:  ret
+
+      IL_0038:  ldc.i4.1
+      IL_0039:  ret
+
+      IL_003a:  ldarg.1
+      IL_003b:  unbox.any  ABC/Expr
+      IL_0040:  brfalse.s  IL_0044
+
+      IL_0042:  ldc.i4.m1
+      IL_0043:  ret
+
+      IL_0044:  ldc.i4.0
+      IL_0045:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class ABC/Expr V_1,
+               class [runtime]System.Collections.IEqualityComparer V_2)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0024
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldarg.0
+      IL_0008:  stloc.1
+      IL_0009:  ldc.i4.0
+      IL_000a:  stloc.0
+      IL_000b:  ldc.i4     0x9e3779b9
+      IL_0010:  ldarg.1
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  ldloc.0
+      IL_0019:  ldc.i4.6
+      IL_001a:  shl
+      IL_001b:  ldloc.0
+      IL_001c:  ldc.i4.2
+      IL_001d:  shr
+      IL_001e:  add
+      IL_001f:  add
+      IL_0020:  add
+      IL_0021:  stloc.0
+      IL_0022:  ldloc.0
+      IL_0023:  ret
+
+      IL_0024:  ldc.i4.0
+      IL_0025:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class ABC/Expr V_2,
+               class ABC/Expr V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0029
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     ABC/Expr
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0027
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  pop
+      IL_0011:  ldarg.0
+      IL_0012:  stloc.2
+      IL_0013:  ldloc.1
+      IL_0014:  stloc.3
+      IL_0015:  ldarg.2
+      IL_0016:  stloc.s    V_4
+      IL_0018:  ldloc.2
+      IL_0019:  ldfld      int32 ABC/Expr::item
+      IL_001e:  ldloc.3
+      IL_001f:  ldfld      int32 ABC/Expr::item
+      IL_0024:  ceq
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+
+      IL_0029:  ldarg.1
+      IL_002a:  ldnull
+      IL_002b:  cgt.un
+      IL_002d:  ldc.i4.0
+      IL_002e:  ceq
+      IL_0030:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001d
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001b
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldloc.0
+      IL_000d:  ldfld      int32 ABC/Expr::item
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  ceq
+      IL_001a:  ret
+
+      IL_001b:  ldc.i4.0
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  ldnull
+      IL_001f:  cgt.un
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool ABC/Expr::Equals(class ABC/Expr)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 ABC/Expr::get_Tag()
+    } 
+    .property instance int32 Item()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .get instance int32 ABC/Expr::get_Item()
+    } 
+  } 
+
+  .class auto ansi serializable nested public beforefieldinit MyExn
+         extends [runtime]System.Exception
+         implements [runtime]System.Collections.IStructuralEquatable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+    .field assembly int32 Data0@
+    .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 ABC/MyExn::Data0@
+      IL_000d:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method family specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  ldarg.2
+      IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                           valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_Data0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 ABC/MyExn::Data0@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0023
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldc.i4     0x9e3779b9
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  castclass  ABC/MyExn
+      IL_0012:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0017:  ldloc.0
+      IL_0018:  ldc.i4.6
+      IL_0019:  shl
+      IL_001a:  ldloc.0
+      IL_001b:  ldc.i4.2
+      IL_001c:  shr
+      IL_001d:  add
+      IL_001e:  add
+      IL_001f:  add
+      IL_0020:  stloc.0
+      IL_0021:  ldloc.0
+      IL_0022:  ret
+
+      IL_0023:  ldc.i4.0
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual instance bool 
+            Equals(object obj,
+                   class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1,
+               object V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_003b
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     [runtime]System.Exception
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0039
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldloc.0
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.2
+      IL_0012:  isinst     ABC/MyExn
+      IL_0017:  ldnull
+      IL_0018:  cgt.un
+      IL_001a:  brfalse.s  IL_0037
+
+      IL_001c:  ldarg.2
+      IL_001d:  stloc.3
+      IL_001e:  ldarg.0
+      IL_001f:  castclass  ABC/MyExn
+      IL_0024:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0029:  ldloc.1
+      IL_002a:  castclass  ABC/MyExn
+      IL_002f:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0034:  ceq
+      IL_0036:  ret
+
+      IL_0037:  ldc.i4.0
+      IL_0038:  ret
+
+      IL_0039:  ldc.i4.0
+      IL_003a:  ret
+
+      IL_003b:  ldarg.1
+      IL_003c:  ldnull
+      IL_003d:  cgt.un
+      IL_003f:  ldc.i4.0
+      IL_0040:  ceq
+      IL_0042:  ret
+    } 
+
+    .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0030
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002e
+
+      IL_0006:  ldarg.1
+      IL_0007:  stloc.0
+      IL_0008:  ldloc.0
+      IL_0009:  isinst     ABC/MyExn
+      IL_000e:  ldnull
+      IL_000f:  cgt.un
+      IL_0011:  brfalse.s  IL_002c
+
+      IL_0013:  ldarg.0
+      IL_0014:  castclass  ABC/MyExn
+      IL_0019:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_001e:  ldarg.1
+      IL_001f:  castclass  ABC/MyExn
+      IL_0024:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0029:  ceq
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+
+      IL_0030:  ldarg.1
+      IL_0031:  ldnull
+      IL_0032:  cgt.un
+      IL_0034:  ldc.i4.0
+      IL_0035:  ceq
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual instance bool Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     [runtime]System.Exception
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool ABC/MyExn::Equals(class [runtime]System.Exception)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Data0()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance int32 ABC/MyExn::get_Data0()
+    } 
+  } 
+
+  .class auto ansi serializable nested public A
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly string x
+    .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldarg.1
+      IL_000a:  stfld      string ABC/A::x
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance string  get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string ABC/A::x
+      IL_0006:  ret
+    } 
+
+    .property instance string X()
+    {
+      .get instance string ABC/A::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public ABC
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested public beforefieldinit Expr
+           extends [runtime]System.Object
+           implements class [runtime]System.IEquatable`1<class ABC/ABC/Expr>,
+                      [runtime]System.Collections.IStructuralEquatable,
+                      class [runtime]System.IComparable`1<class ABC/ABC/Expr>,
+                      [runtime]System.IComparable,
+                      [runtime]System.Collections.IStructuralComparable
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                     61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public static class ABC/ABC/Expr NewNum(int32 item) cil managed
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void ABC/ABC/Expr::.ctor(int32)
+        IL_0006:  ret
+      } 
+
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0C 41 42 43 2B 41 42 43 2B 45   
+                                                                                                                                 78 70 72 00 00 )                                  
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 ABC/ABC/Expr::item
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Tag() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  pop
+        IL_0002:  ldc.i4.0
+        IL_0003:  ret
+      } 
+
+      .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+0.8A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public strict virtual instance string ToString() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/ABC/Expr>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(class ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IComparer V_2,
+                 int32 V_3,
+                 int32 V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_002f
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002d
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.0
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.1
+        IL_001a:  ldfld      int32 ABC/ABC/Expr::item
+        IL_001f:  stloc.s    V_4
+        IL_0021:  ldloc.3
+        IL_0022:  ldloc.s    V_4
+        IL_0024:  cgt
+        IL_0026:  ldloc.3
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  clt
+        IL_002b:  sub
+        IL_002c:  ret
+
+        IL_002d:  ldc.i4.1
+        IL_002e:  ret
+
+        IL_002f:  ldarg.1
+        IL_0030:  brfalse.s  IL_0034
+
+        IL_0032:  ldc.i4.m1
+        IL_0033:  ret
+
+        IL_0034:  ldc.i4.0
+        IL_0035:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  unbox.any  ABC/ABC/Expr
+        IL_0007:  callvirt   instance int32 ABC/ABC/Expr::CompareTo(class ABC/ABC/Expr)
+        IL_000c:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance int32  CompareTo(object obj,
+                                        class [runtime]System.Collections.IComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class ABC/ABC/Expr V_2,
+                 class [runtime]System.Collections.IComparer V_3,
+                 int32 V_4,
+                 int32 V_5)
+        IL_0000:  ldarg.1
+        IL_0001:  unbox.any  ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  brfalse.s  IL_003a
+
+        IL_000a:  ldarg.1
+        IL_000b:  unbox.any  ABC/ABC/Expr
+        IL_0010:  brfalse.s  IL_0038
+
+        IL_0012:  ldarg.0
+        IL_0013:  pop
+        IL_0014:  ldarg.0
+        IL_0015:  stloc.1
+        IL_0016:  ldloc.0
+        IL_0017:  stloc.2
+        IL_0018:  ldarg.2
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.1
+        IL_001b:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0020:  stloc.s    V_4
+        IL_0022:  ldloc.2
+        IL_0023:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0028:  stloc.s    V_5
+        IL_002a:  ldloc.s    V_4
+        IL_002c:  ldloc.s    V_5
+        IL_002e:  cgt
+        IL_0030:  ldloc.s    V_4
+        IL_0032:  ldloc.s    V_5
+        IL_0034:  clt
+        IL_0036:  sub
+        IL_0037:  ret
+
+        IL_0038:  ldc.i4.1
+        IL_0039:  ret
+
+        IL_003a:  ldarg.1
+        IL_003b:  unbox.any  ABC/ABC/Expr
+        IL_0040:  brfalse.s  IL_0044
+
+        IL_0042:  ldc.i4.m1
+        IL_0043:  ret
+
+        IL_0044:  ldc.i4.0
+        IL_0045:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IEqualityComparer V_2)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0024
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldarg.0
+        IL_0006:  pop
+        IL_0007:  ldarg.0
+        IL_0008:  stloc.1
+        IL_0009:  ldc.i4.0
+        IL_000a:  stloc.0
+        IL_000b:  ldc.i4     0x9e3779b9
+        IL_0010:  ldarg.1
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  ldloc.0
+        IL_0019:  ldc.i4.6
+        IL_001a:  shl
+        IL_001b:  ldloc.0
+        IL_001c:  ldc.i4.2
+        IL_001d:  shr
+        IL_001e:  add
+        IL_001f:  add
+        IL_0020:  add
+        IL_0021:  stloc.0
+        IL_0022:  ldloc.0
+        IL_0023:  ret
+
+        IL_0024:  ldc.i4.0
+        IL_0025:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 ABC/ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance bool  Equals(object obj,
+                                    class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class ABC/ABC/Expr V_2,
+                 class ABC/ABC/Expr V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0029
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     ABC/ABC/Expr
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0027
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldarg.0
+        IL_0010:  pop
+        IL_0011:  ldarg.0
+        IL_0012:  stloc.2
+        IL_0013:  ldloc.1
+        IL_0014:  stloc.3
+        IL_0015:  ldarg.2
+        IL_0016:  stloc.s    V_4
+        IL_0018:  ldloc.2
+        IL_0019:  ldfld      int32 ABC/ABC/Expr::item
+        IL_001e:  ldloc.3
+        IL_001f:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0024:  ceq
+        IL_0026:  ret
+
+        IL_0027:  ldc.i4.0
+        IL_0028:  ret
+
+        IL_0029:  ldarg.1
+        IL_002a:  ldnull
+        IL_002b:  cgt.un
+        IL_002d:  ldc.i4.0
+        IL_002e:  ceq
+        IL_0030:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(class ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_001d
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_001b
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldloc.0
+        IL_000d:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  ceq
+        IL_001a:  ret
+
+        IL_001b:  ldc.i4.0
+        IL_001c:  ret
+
+        IL_001d:  ldarg.1
+        IL_001e:  ldnull
+        IL_001f:  cgt.un
+        IL_0021:  ldc.i4.0
+        IL_0022:  ceq
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool ABC/ABC/Expr::Equals(class ABC/ABC/Expr)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Tag()
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+        .get instance int32 ABC/ABC/Expr::get_Tag()
+      } 
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 ABC/ABC/Expr::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit MyExn
+           extends [runtime]System.Exception
+           implements [runtime]System.Collections.IStructuralEquatable
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+      .field assembly int32 Data0@
+      .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 ABC/ABC/MyExn::Data0@
+        IL_000d:  ret
+      } 
+
+      .method public specialname rtspecialname instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method family specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  ldarg.2
+        IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                             valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+        IL_0008:  ret
+      } 
+
+      .method public hidebysig specialname instance int32  get_Data0() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 ABC/ABC/MyExn::Data0@
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [runtime]System.Collections.IEqualityComparer V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0023
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldc.i4     0x9e3779b9
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldarg.0
+        IL_000d:  castclass  ABC/ABC/MyExn
+        IL_0012:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0017:  ldloc.0
+        IL_0018:  ldc.i4.6
+        IL_0019:  shl
+        IL_001a:  ldloc.0
+        IL_001b:  ldc.i4.2
+        IL_001c:  shr
+        IL_001d:  add
+        IL_001e:  add
+        IL_001f:  add
+        IL_0020:  stloc.0
+        IL_0021:  ldloc.0
+        IL_0022:  ret
+
+        IL_0023:  ldc.i4.0
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 ABC/ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual instance bool 
+              Equals(object obj,
+                     class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1,
+                 object V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_003b
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     [runtime]System.Exception
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0039
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldloc.0
+        IL_0010:  stloc.2
+        IL_0011:  ldloc.2
+        IL_0012:  isinst     ABC/ABC/MyExn
+        IL_0017:  ldnull
+        IL_0018:  cgt.un
+        IL_001a:  brfalse.s  IL_0037
+
+        IL_001c:  ldarg.2
+        IL_001d:  stloc.3
+        IL_001e:  ldarg.0
+        IL_001f:  castclass  ABC/ABC/MyExn
+        IL_0024:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ldloc.1
+        IL_002a:  castclass  ABC/ABC/MyExn
+        IL_002f:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0034:  ceq
+        IL_0036:  ret
+
+        IL_0037:  ldc.i4.0
+        IL_0038:  ret
+
+        IL_0039:  ldc.i4.0
+        IL_003a:  ret
+
+        IL_003b:  ldarg.1
+        IL_003c:  ldnull
+        IL_003d:  cgt.un
+        IL_003f:  ldc.i4.0
+        IL_0040:  ceq
+        IL_0042:  ret
+      } 
+
+      .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (object V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0030
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002e
+
+        IL_0006:  ldarg.1
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  isinst     ABC/ABC/MyExn
+        IL_000e:  ldnull
+        IL_000f:  cgt.un
+        IL_0011:  brfalse.s  IL_002c
+
+        IL_0013:  ldarg.0
+        IL_0014:  castclass  ABC/ABC/MyExn
+        IL_0019:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_001e:  ldarg.1
+        IL_001f:  castclass  ABC/ABC/MyExn
+        IL_0024:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ceq
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+
+        IL_0030:  ldarg.1
+        IL_0031:  ldnull
+        IL_0032:  cgt.un
+        IL_0034:  ldc.i4.0
+        IL_0035:  ceq
+        IL_0037:  ret
+      } 
+
+      .method public hidebysig virtual instance bool Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     [runtime]System.Exception
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool ABC/ABC/MyExn::Equals(class [runtime]System.Exception)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Data0()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+        .get instance int32 ABC/ABC/MyExn::get_Data0()
+      } 
+    } 
+
+    .class auto ansi serializable nested public A
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+      .field assembly string x
+      .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  ldarg.1
+        IL_000a:  stfld      string ABC/ABC/A::x
+        IL_000f:  ret
+      } 
+
+      .method public hidebysig specialname instance string  get_X() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      string ABC/ABC/A::x
+        IL_0006:  ret
+      } 
+
+      .property instance string X()
+      {
+        .get instance string ABC/ABC/A::get_X()
+      } 
+    } 
+
+    .method public static int32  'add'(int32 x,
+                                       int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public specialname static string get_greeting() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  ret
+    } 
+
+    .property string greeting()
+    {
+      .get string ABC/ABC::get_greeting()
+    } 
+  } 
+
+  .method public static int32  'add'(int32 x,
+                                     int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public specialname static string get_greeting() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello"
+    IL_0005:  ret
+  } 
+
+  .property string greeting()
+  {
+    .get string ABC::get_greeting()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$ABC
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+.class private auto ansi serializable sealed System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+       extends [runtime]System.Enum
+{
+  .custom instance void [runtime]System.FlagsAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field public specialname rtspecialname int32 value__
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes All = int32(0xFFFFFFFF)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes None = int32(0x00000000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicParameterlessConstructor = int32(0x00000001)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicConstructors = int32(0x00000003)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicConstructors = int32(0x00000004)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicMethods = int32(0x00000008)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicMethods = int32(0x00000010)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicFields = int32(0x00000020)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicFields = int32(0x00000040)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicNestedTypes = int32(0x00000080)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicNestedTypes = int32(0x00000100)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicProperties = int32(0x00000200)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicProperties = int32(0x00000400)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicEvents = int32(0x00000800)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicEvents = int32(0x00001000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes Interfaces = int32(0x00002000)
+} 
+
+.class private auto ansi beforefieldinit System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute
+       extends [runtime]System.Attribute
+{
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private class [runtime]System.Type Type@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public specialname rtspecialname 
+          instance void  .ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType,
+                               class [runtime]System.Type Type) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Attribute::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_000d:  ldarg.0
+    IL_000e:  ldarg.2
+    IL_000f:  stfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0014:  ret
+  } 
+
+  .method public hidebysig specialname instance class [runtime]System.Type get_Type() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes get_MemberType() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_0006:  ret
+  } 
+
+  .property instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+          MemberType()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_MemberType()
+  } 
+  .property instance class [runtime]System.Type
+          Type()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_Type()
+  } 
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOn.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOn.il.netcore.debug.bsl
new file mode 100644
index 00000000000..61decc2a571
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOn.il.netcore.debug.bsl
@@ -0,0 +1,1521 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed ABC
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Expr
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class ABC/Expr>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class ABC/Expr>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                         61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field assembly initonly int32 item
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public static class ABC/Expr NewNum(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void ABC/Expr::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+    {
+      .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                              class [runtime]System.Type) = ( 01 00 60 06 00 00 08 41 42 43 2B 45 78 70 72 00   
+                                                                                                                                                     00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 ABC/Expr::item
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Item() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 ABC/Expr::item
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/Expr>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4,
+               class [runtime]System.Collections.IComparer V_5,
+               int32 V_6,
+               int32 V_7)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_003b
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_0039
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.0
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.1
+      IL_001a:  ldfld      int32 ABC/Expr::item
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.2
+      IL_0022:  stloc.s    V_5
+      IL_0024:  ldloc.3
+      IL_0025:  stloc.s    V_6
+      IL_0027:  ldloc.s    V_4
+      IL_0029:  stloc.s    V_7
+      IL_002b:  ldloc.s    V_6
+      IL_002d:  ldloc.s    V_7
+      IL_002f:  cgt
+      IL_0031:  ldloc.s    V_6
+      IL_0033:  ldloc.s    V_7
+      IL_0035:  clt
+      IL_0037:  sub
+      IL_0038:  ret
+
+      IL_0039:  ldc.i4.1
+      IL_003a:  ret
+
+      IL_003b:  ldarg.1
+      IL_003c:  brfalse.s  IL_0040
+
+      IL_003e:  ldc.i4.m1
+      IL_003f:  ret
+
+      IL_0040:  ldc.i4.0
+      IL_0041:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  ABC/Expr
+      IL_0007:  callvirt   instance int32 ABC/Expr::CompareTo(class ABC/Expr)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class ABC/Expr V_2,
+               class [runtime]System.Collections.IComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IComparer V_6,
+               int32 V_7,
+               int32 V_8)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_0045
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  ABC/Expr
+      IL_0010:  brfalse.s  IL_0043
+
+      IL_0012:  ldarg.0
+      IL_0013:  pop
+      IL_0014:  ldarg.0
+      IL_0015:  stloc.1
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  ldarg.2
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.1
+      IL_001b:  ldfld      int32 ABC/Expr::item
+      IL_0020:  stloc.s    V_4
+      IL_0022:  ldloc.2
+      IL_0023:  ldfld      int32 ABC/Expr::item
+      IL_0028:  stloc.s    V_5
+      IL_002a:  ldloc.3
+      IL_002b:  stloc.s    V_6
+      IL_002d:  ldloc.s    V_4
+      IL_002f:  stloc.s    V_7
+      IL_0031:  ldloc.s    V_5
+      IL_0033:  stloc.s    V_8
+      IL_0035:  ldloc.s    V_7
+      IL_0037:  ldloc.s    V_8
+      IL_0039:  cgt
+      IL_003b:  ldloc.s    V_7
+      IL_003d:  ldloc.s    V_8
+      IL_003f:  clt
+      IL_0041:  sub
+      IL_0042:  ret
+
+      IL_0043:  ldc.i4.1
+      IL_0044:  ret
+
+      IL_0045:  ldarg.1
+      IL_0046:  unbox.any  ABC/Expr
+      IL_004b:  brfalse.s  IL_004f
+
+      IL_004d:  ldc.i4.m1
+      IL_004e:  ret
+
+      IL_004f:  ldc.i4.0
+      IL_0050:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class ABC/Expr V_1,
+               class [runtime]System.Collections.IEqualityComparer V_2,
+               int32 V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0029
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldarg.0
+      IL_0008:  stloc.1
+      IL_0009:  ldc.i4.0
+      IL_000a:  stloc.0
+      IL_000b:  ldc.i4     0x9e3779b9
+      IL_0010:  ldarg.1
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.2
+      IL_001a:  stloc.s    V_4
+      IL_001c:  ldloc.3
+      IL_001d:  ldloc.0
+      IL_001e:  ldc.i4.6
+      IL_001f:  shl
+      IL_0020:  ldloc.0
+      IL_0021:  ldc.i4.2
+      IL_0022:  shr
+      IL_0023:  add
+      IL_0024:  add
+      IL_0025:  add
+      IL_0026:  stloc.0
+      IL_0027:  ldloc.0
+      IL_0028:  ret
+
+      IL_0029:  ldc.i4.0
+      IL_002a:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class ABC/Expr V_2,
+               class ABC/Expr V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4,
+               int32 V_5,
+               int32 V_6,
+               class [runtime]System.Collections.IEqualityComparer V_7)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0035
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     ABC/Expr
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0033
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  pop
+      IL_0011:  ldarg.0
+      IL_0012:  stloc.2
+      IL_0013:  ldloc.1
+      IL_0014:  stloc.3
+      IL_0015:  ldarg.2
+      IL_0016:  stloc.s    V_4
+      IL_0018:  ldloc.2
+      IL_0019:  ldfld      int32 ABC/Expr::item
+      IL_001e:  stloc.s    V_5
+      IL_0020:  ldloc.3
+      IL_0021:  ldfld      int32 ABC/Expr::item
+      IL_0026:  stloc.s    V_6
+      IL_0028:  ldloc.s    V_4
+      IL_002a:  stloc.s    V_7
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  ldloc.s    V_6
+      IL_0030:  ceq
+      IL_0032:  ret
+
+      IL_0033:  ldc.i4.0
+      IL_0034:  ret
+
+      IL_0035:  ldarg.1
+      IL_0036:  ldnull
+      IL_0037:  cgt.un
+      IL_0039:  ldc.i4.0
+      IL_003a:  ceq
+      IL_003c:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001d
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001b
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldloc.0
+      IL_000d:  ldfld      int32 ABC/Expr::item
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  ceq
+      IL_001a:  ret
+
+      IL_001b:  ldc.i4.0
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  ldnull
+      IL_001f:  cgt.un
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool ABC/Expr::Equals(class ABC/Expr)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 ABC/Expr::get_Tag()
+    } 
+    .property instance int32 Item()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .get instance int32 ABC/Expr::get_Item()
+    } 
+  } 
+
+  .class auto ansi serializable nested public beforefieldinit MyExn
+         extends [runtime]System.Exception
+         implements [runtime]System.Collections.IStructuralEquatable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+    .field assembly int32 Data0@
+    .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 ABC/MyExn::Data0@
+      IL_000d:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method family specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  ldarg.2
+      IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_Data0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 ABC/MyExn::Data0@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1,
+               int32 V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0027
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldc.i4     0x9e3779b9
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  castclass  ABC/MyExn
+      IL_0012:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0017:  stloc.2
+      IL_0018:  ldloc.1
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.2
+      IL_001b:  ldloc.0
+      IL_001c:  ldc.i4.6
+      IL_001d:  shl
+      IL_001e:  ldloc.0
+      IL_001f:  ldc.i4.2
+      IL_0020:  shr
+      IL_0021:  add
+      IL_0022:  add
+      IL_0023:  add
+      IL_0024:  stloc.0
+      IL_0025:  ldloc.0
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual instance bool 
+            Equals(object obj,
+                   class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1,
+               object V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IEqualityComparer V_6)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0046
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     [runtime]System.Exception
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0044
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldloc.0
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.2
+      IL_0012:  isinst     ABC/MyExn
+      IL_0017:  ldnull
+      IL_0018:  cgt.un
+      IL_001a:  brfalse.s  IL_0042
+
+      IL_001c:  ldarg.2
+      IL_001d:  stloc.3
+      IL_001e:  ldarg.0
+      IL_001f:  castclass  ABC/MyExn
+      IL_0024:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0029:  stloc.s    V_4
+      IL_002b:  ldloc.1
+      IL_002c:  castclass  ABC/MyExn
+      IL_0031:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0036:  stloc.s    V_5
+      IL_0038:  ldloc.3
+      IL_0039:  stloc.s    V_6
+      IL_003b:  ldloc.s    V_4
+      IL_003d:  ldloc.s    V_5
+      IL_003f:  ceq
+      IL_0041:  ret
+
+      IL_0042:  ldc.i4.0
+      IL_0043:  ret
+
+      IL_0044:  ldc.i4.0
+      IL_0045:  ret
+
+      IL_0046:  ldarg.1
+      IL_0047:  ldnull
+      IL_0048:  cgt.un
+      IL_004a:  ldc.i4.0
+      IL_004b:  ceq
+      IL_004d:  ret
+    } 
+
+    .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0030
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002e
+
+      IL_0006:  ldarg.1
+      IL_0007:  stloc.0
+      IL_0008:  ldloc.0
+      IL_0009:  isinst     ABC/MyExn
+      IL_000e:  ldnull
+      IL_000f:  cgt.un
+      IL_0011:  brfalse.s  IL_002c
+
+      IL_0013:  ldarg.0
+      IL_0014:  castclass  ABC/MyExn
+      IL_0019:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_001e:  ldarg.1
+      IL_001f:  castclass  ABC/MyExn
+      IL_0024:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0029:  ceq
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+
+      IL_0030:  ldarg.1
+      IL_0031:  ldnull
+      IL_0032:  cgt.un
+      IL_0034:  ldc.i4.0
+      IL_0035:  ceq
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual instance bool Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     [runtime]System.Exception
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool ABC/MyExn::Equals(class [runtime]System.Exception)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Data0()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance int32 ABC/MyExn::get_Data0()
+    } 
+  } 
+
+  .class auto ansi serializable nested public A
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly string x
+    .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldarg.1
+      IL_000a:  stfld      string ABC/A::x
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance string  get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string ABC/A::x
+      IL_0006:  ret
+    } 
+
+    .property instance string X()
+    {
+      .get instance string ABC/A::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public ABC
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested public beforefieldinit Expr
+           extends [runtime]System.Object
+           implements class [runtime]System.IEquatable`1<class ABC/ABC/Expr>,
+                      [runtime]System.Collections.IStructuralEquatable,
+                      class [runtime]System.IComparable`1<class ABC/ABC/Expr>,
+                      [runtime]System.IComparable,
+                      [runtime]System.Collections.IStructuralComparable
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                           61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public static class ABC/ABC/Expr NewNum(int32 item) cil managed
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void ABC/ABC/Expr::.ctor(int32)
+        IL_0006:  ret
+      } 
+
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0C 41 42 43 2B 41 42 43 2B 45   
+                                                                                                                                                       78 70 72 00 00 )                                  
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 ABC/ABC/Expr::item
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Tag() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  pop
+        IL_0002:  ldc.i4.0
+        IL_0003:  ret
+      } 
+
+      .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+0.8A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public strict virtual instance string ToString() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/ABC/Expr>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(class ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IComparer V_2,
+                 int32 V_3,
+                 int32 V_4,
+                 class [runtime]System.Collections.IComparer V_5,
+                 int32 V_6,
+                 int32 V_7)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_003b
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_0039
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.0
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.1
+        IL_001a:  ldfld      int32 ABC/ABC/Expr::item
+        IL_001f:  stloc.s    V_4
+        IL_0021:  ldloc.2
+        IL_0022:  stloc.s    V_5
+        IL_0024:  ldloc.3
+        IL_0025:  stloc.s    V_6
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  stloc.s    V_7
+        IL_002b:  ldloc.s    V_6
+        IL_002d:  ldloc.s    V_7
+        IL_002f:  cgt
+        IL_0031:  ldloc.s    V_6
+        IL_0033:  ldloc.s    V_7
+        IL_0035:  clt
+        IL_0037:  sub
+        IL_0038:  ret
+
+        IL_0039:  ldc.i4.1
+        IL_003a:  ret
+
+        IL_003b:  ldarg.1
+        IL_003c:  brfalse.s  IL_0040
+
+        IL_003e:  ldc.i4.m1
+        IL_003f:  ret
+
+        IL_0040:  ldc.i4.0
+        IL_0041:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  unbox.any  ABC/ABC/Expr
+        IL_0007:  callvirt   instance int32 ABC/ABC/Expr::CompareTo(class ABC/ABC/Expr)
+        IL_000c:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance int32  CompareTo(object obj,
+                                        class [runtime]System.Collections.IComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class ABC/ABC/Expr V_2,
+                 class [runtime]System.Collections.IComparer V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class [runtime]System.Collections.IComparer V_6,
+                 int32 V_7,
+                 int32 V_8)
+        IL_0000:  ldarg.1
+        IL_0001:  unbox.any  ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  brfalse.s  IL_0045
+
+        IL_000a:  ldarg.1
+        IL_000b:  unbox.any  ABC/ABC/Expr
+        IL_0010:  brfalse.s  IL_0043
+
+        IL_0012:  ldarg.0
+        IL_0013:  pop
+        IL_0014:  ldarg.0
+        IL_0015:  stloc.1
+        IL_0016:  ldloc.0
+        IL_0017:  stloc.2
+        IL_0018:  ldarg.2
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.1
+        IL_001b:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0020:  stloc.s    V_4
+        IL_0022:  ldloc.2
+        IL_0023:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0028:  stloc.s    V_5
+        IL_002a:  ldloc.3
+        IL_002b:  stloc.s    V_6
+        IL_002d:  ldloc.s    V_4
+        IL_002f:  stloc.s    V_7
+        IL_0031:  ldloc.s    V_5
+        IL_0033:  stloc.s    V_8
+        IL_0035:  ldloc.s    V_7
+        IL_0037:  ldloc.s    V_8
+        IL_0039:  cgt
+        IL_003b:  ldloc.s    V_7
+        IL_003d:  ldloc.s    V_8
+        IL_003f:  clt
+        IL_0041:  sub
+        IL_0042:  ret
+
+        IL_0043:  ldc.i4.1
+        IL_0044:  ret
+
+        IL_0045:  ldarg.1
+        IL_0046:  unbox.any  ABC/ABC/Expr
+        IL_004b:  brfalse.s  IL_004f
+
+        IL_004d:  ldc.i4.m1
+        IL_004e:  ret
+
+        IL_004f:  ldc.i4.0
+        IL_0050:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IEqualityComparer V_2,
+                 int32 V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0029
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldarg.0
+        IL_0006:  pop
+        IL_0007:  ldarg.0
+        IL_0008:  stloc.1
+        IL_0009:  ldc.i4.0
+        IL_000a:  stloc.0
+        IL_000b:  ldc.i4     0x9e3779b9
+        IL_0010:  ldarg.1
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.2
+        IL_001a:  stloc.s    V_4
+        IL_001c:  ldloc.3
+        IL_001d:  ldloc.0
+        IL_001e:  ldc.i4.6
+        IL_001f:  shl
+        IL_0020:  ldloc.0
+        IL_0021:  ldc.i4.2
+        IL_0022:  shr
+        IL_0023:  add
+        IL_0024:  add
+        IL_0025:  add
+        IL_0026:  stloc.0
+        IL_0027:  ldloc.0
+        IL_0028:  ret
+
+        IL_0029:  ldc.i4.0
+        IL_002a:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 ABC/ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance bool  Equals(object obj,
+                                    class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class ABC/ABC/Expr V_2,
+                 class ABC/ABC/Expr V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4,
+                 int32 V_5,
+                 int32 V_6,
+                 class [runtime]System.Collections.IEqualityComparer V_7)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0035
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     ABC/ABC/Expr
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0033
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldarg.0
+        IL_0010:  pop
+        IL_0011:  ldarg.0
+        IL_0012:  stloc.2
+        IL_0013:  ldloc.1
+        IL_0014:  stloc.3
+        IL_0015:  ldarg.2
+        IL_0016:  stloc.s    V_4
+        IL_0018:  ldloc.2
+        IL_0019:  ldfld      int32 ABC/ABC/Expr::item
+        IL_001e:  stloc.s    V_5
+        IL_0020:  ldloc.3
+        IL_0021:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0026:  stloc.s    V_6
+        IL_0028:  ldloc.s    V_4
+        IL_002a:  stloc.s    V_7
+        IL_002c:  ldloc.s    V_5
+        IL_002e:  ldloc.s    V_6
+        IL_0030:  ceq
+        IL_0032:  ret
+
+        IL_0033:  ldc.i4.0
+        IL_0034:  ret
+
+        IL_0035:  ldarg.1
+        IL_0036:  ldnull
+        IL_0037:  cgt.un
+        IL_0039:  ldc.i4.0
+        IL_003a:  ceq
+        IL_003c:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(class ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_001d
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_001b
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldloc.0
+        IL_000d:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  ceq
+        IL_001a:  ret
+
+        IL_001b:  ldc.i4.0
+        IL_001c:  ret
+
+        IL_001d:  ldarg.1
+        IL_001e:  ldnull
+        IL_001f:  cgt.un
+        IL_0021:  ldc.i4.0
+        IL_0022:  ceq
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool ABC/ABC/Expr::Equals(class ABC/ABC/Expr)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Tag()
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+        .get instance int32 ABC/ABC/Expr::get_Tag()
+      } 
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 ABC/ABC/Expr::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit MyExn
+           extends [runtime]System.Exception
+           implements [runtime]System.Collections.IStructuralEquatable
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+      .field assembly int32 Data0@
+      .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 ABC/ABC/MyExn::Data0@
+        IL_000d:  ret
+      } 
+
+      .method public specialname rtspecialname instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method family specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  ldarg.2
+        IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+        IL_0008:  ret
+      } 
+
+      .method public hidebysig specialname instance int32  get_Data0() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 ABC/ABC/MyExn::Data0@
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [runtime]System.Collections.IEqualityComparer V_1,
+                 int32 V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0027
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldc.i4     0x9e3779b9
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldarg.0
+        IL_000d:  castclass  ABC/ABC/MyExn
+        IL_0012:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0017:  stloc.2
+        IL_0018:  ldloc.1
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.2
+        IL_001b:  ldloc.0
+        IL_001c:  ldc.i4.6
+        IL_001d:  shl
+        IL_001e:  ldloc.0
+        IL_001f:  ldc.i4.2
+        IL_0020:  shr
+        IL_0021:  add
+        IL_0022:  add
+        IL_0023:  add
+        IL_0024:  stloc.0
+        IL_0025:  ldloc.0
+        IL_0026:  ret
+
+        IL_0027:  ldc.i4.0
+        IL_0028:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 ABC/ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual instance bool 
+              Equals(object obj,
+                     class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1,
+                 object V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class [runtime]System.Collections.IEqualityComparer V_6)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0046
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     [runtime]System.Exception
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0044
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldloc.0
+        IL_0010:  stloc.2
+        IL_0011:  ldloc.2
+        IL_0012:  isinst     ABC/ABC/MyExn
+        IL_0017:  ldnull
+        IL_0018:  cgt.un
+        IL_001a:  brfalse.s  IL_0042
+
+        IL_001c:  ldarg.2
+        IL_001d:  stloc.3
+        IL_001e:  ldarg.0
+        IL_001f:  castclass  ABC/ABC/MyExn
+        IL_0024:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0029:  stloc.s    V_4
+        IL_002b:  ldloc.1
+        IL_002c:  castclass  ABC/ABC/MyExn
+        IL_0031:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0036:  stloc.s    V_5
+        IL_0038:  ldloc.3
+        IL_0039:  stloc.s    V_6
+        IL_003b:  ldloc.s    V_4
+        IL_003d:  ldloc.s    V_5
+        IL_003f:  ceq
+        IL_0041:  ret
+
+        IL_0042:  ldc.i4.0
+        IL_0043:  ret
+
+        IL_0044:  ldc.i4.0
+        IL_0045:  ret
+
+        IL_0046:  ldarg.1
+        IL_0047:  ldnull
+        IL_0048:  cgt.un
+        IL_004a:  ldc.i4.0
+        IL_004b:  ceq
+        IL_004d:  ret
+      } 
+
+      .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (object V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0030
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002e
+
+        IL_0006:  ldarg.1
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  isinst     ABC/ABC/MyExn
+        IL_000e:  ldnull
+        IL_000f:  cgt.un
+        IL_0011:  brfalse.s  IL_002c
+
+        IL_0013:  ldarg.0
+        IL_0014:  castclass  ABC/ABC/MyExn
+        IL_0019:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_001e:  ldarg.1
+        IL_001f:  castclass  ABC/ABC/MyExn
+        IL_0024:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ceq
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+
+        IL_0030:  ldarg.1
+        IL_0031:  ldnull
+        IL_0032:  cgt.un
+        IL_0034:  ldc.i4.0
+        IL_0035:  ceq
+        IL_0037:  ret
+      } 
+
+      .method public hidebysig virtual instance bool Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     [runtime]System.Exception
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool ABC/ABC/MyExn::Equals(class [runtime]System.Exception)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Data0()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+        .get instance int32 ABC/ABC/MyExn::get_Data0()
+      } 
+    } 
+
+    .class auto ansi serializable nested public A
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+      .field assembly string x
+      .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  ldarg.1
+        IL_000a:  stfld      string ABC/ABC/A::x
+        IL_000f:  ret
+      } 
+
+      .method public hidebysig specialname instance string  get_X() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      string ABC/ABC/A::x
+        IL_0006:  ret
+      } 
+
+      .property instance string X()
+      {
+        .get instance string ABC/ABC/A::get_X()
+      } 
+    } 
+
+    .method public static int32  'add'(int32 x,
+                                       int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public specialname static string get_greeting() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  ret
+    } 
+
+    .property string greeting()
+    {
+      .get string ABC/ABC::get_greeting()
+    } 
+  } 
+
+  .method public static int32  'add'(int32 x,
+                                     int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public specialname static string get_greeting() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello"
+    IL_0005:  ret
+  } 
+
+  .property string greeting()
+  {
+    .get string ABC::get_greeting()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$ABC
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOn.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOn.il.netcore.release.bsl
new file mode 100644
index 00000000000..6ebfb734de4
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelModule60.fs.RealInternalSignatureOn.il.netcore.release.bsl
@@ -0,0 +1,1425 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed ABC
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Expr
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class ABC/Expr>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class ABC/Expr>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                         61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field assembly initonly int32 item
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public static class ABC/Expr NewNum(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void ABC/Expr::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+    {
+      .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                              class [runtime]System.Type) = ( 01 00 60 06 00 00 08 41 42 43 2B 45 78 70 72 00   
+                                                                                                                                                     00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 ABC/Expr::item
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Item() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 ABC/Expr::item
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/Expr>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_002f
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002d
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.0
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.1
+      IL_001a:  ldfld      int32 ABC/Expr::item
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.3
+      IL_0022:  ldloc.s    V_4
+      IL_0024:  cgt
+      IL_0026:  ldloc.3
+      IL_0027:  ldloc.s    V_4
+      IL_0029:  clt
+      IL_002b:  sub
+      IL_002c:  ret
+
+      IL_002d:  ldc.i4.1
+      IL_002e:  ret
+
+      IL_002f:  ldarg.1
+      IL_0030:  brfalse.s  IL_0034
+
+      IL_0032:  ldc.i4.m1
+      IL_0033:  ret
+
+      IL_0034:  ldc.i4.0
+      IL_0035:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  ABC/Expr
+      IL_0007:  callvirt   instance int32 ABC/Expr::CompareTo(class ABC/Expr)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class ABC/Expr V_2,
+               class [runtime]System.Collections.IComparer V_3,
+               int32 V_4,
+               int32 V_5)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_003a
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  ABC/Expr
+      IL_0010:  brfalse.s  IL_0038
+
+      IL_0012:  ldarg.0
+      IL_0013:  pop
+      IL_0014:  ldarg.0
+      IL_0015:  stloc.1
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  ldarg.2
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.1
+      IL_001b:  ldfld      int32 ABC/Expr::item
+      IL_0020:  stloc.s    V_4
+      IL_0022:  ldloc.2
+      IL_0023:  ldfld      int32 ABC/Expr::item
+      IL_0028:  stloc.s    V_5
+      IL_002a:  ldloc.s    V_4
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  cgt
+      IL_0030:  ldloc.s    V_4
+      IL_0032:  ldloc.s    V_5
+      IL_0034:  clt
+      IL_0036:  sub
+      IL_0037:  ret
+
+      IL_0038:  ldc.i4.1
+      IL_0039:  ret
+
+      IL_003a:  ldarg.1
+      IL_003b:  unbox.any  ABC/Expr
+      IL_0040:  brfalse.s  IL_0044
+
+      IL_0042:  ldc.i4.m1
+      IL_0043:  ret
+
+      IL_0044:  ldc.i4.0
+      IL_0045:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class ABC/Expr V_1,
+               class [runtime]System.Collections.IEqualityComparer V_2)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0024
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldarg.0
+      IL_0008:  stloc.1
+      IL_0009:  ldc.i4.0
+      IL_000a:  stloc.0
+      IL_000b:  ldc.i4     0x9e3779b9
+      IL_0010:  ldarg.1
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  ldloc.0
+      IL_0019:  ldc.i4.6
+      IL_001a:  shl
+      IL_001b:  ldloc.0
+      IL_001c:  ldc.i4.2
+      IL_001d:  shr
+      IL_001e:  add
+      IL_001f:  add
+      IL_0020:  add
+      IL_0021:  stloc.0
+      IL_0022:  ldloc.0
+      IL_0023:  ret
+
+      IL_0024:  ldc.i4.0
+      IL_0025:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1,
+               class ABC/Expr V_2,
+               class ABC/Expr V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0029
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     ABC/Expr
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0027
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  pop
+      IL_0011:  ldarg.0
+      IL_0012:  stloc.2
+      IL_0013:  ldloc.1
+      IL_0014:  stloc.3
+      IL_0015:  ldarg.2
+      IL_0016:  stloc.s    V_4
+      IL_0018:  ldloc.2
+      IL_0019:  ldfld      int32 ABC/Expr::item
+      IL_001e:  ldloc.3
+      IL_001f:  ldfld      int32 ABC/Expr::item
+      IL_0024:  ceq
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+
+      IL_0029:  ldarg.1
+      IL_002a:  ldnull
+      IL_002b:  cgt.un
+      IL_002d:  ldc.i4.0
+      IL_002e:  ceq
+      IL_0030:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0,
+               class ABC/Expr V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001d
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001b
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldloc.0
+      IL_000d:  ldfld      int32 ABC/Expr::item
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 ABC/Expr::item
+      IL_0018:  ceq
+      IL_001a:  ret
+
+      IL_001b:  ldc.i4.0
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  ldnull
+      IL_001f:  cgt.un
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class ABC/Expr V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool ABC/Expr::Equals(class ABC/Expr)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 ABC/Expr::get_Tag()
+    } 
+    .property instance int32 Item()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .get instance int32 ABC/Expr::get_Item()
+    } 
+  } 
+
+  .class auto ansi serializable nested public beforefieldinit MyExn
+         extends [runtime]System.Exception
+         implements [runtime]System.Collections.IStructuralEquatable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+    .field assembly int32 Data0@
+    .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 ABC/MyExn::Data0@
+      IL_000d:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method family specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  ldarg.2
+      IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_Data0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 ABC/MyExn::Data0@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0023
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldc.i4     0x9e3779b9
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  castclass  ABC/MyExn
+      IL_0012:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0017:  ldloc.0
+      IL_0018:  ldc.i4.6
+      IL_0019:  shl
+      IL_001a:  ldloc.0
+      IL_001b:  ldc.i4.2
+      IL_001c:  shr
+      IL_001d:  add
+      IL_001e:  add
+      IL_001f:  add
+      IL_0020:  stloc.0
+      IL_0021:  ldloc.0
+      IL_0022:  ret
+
+      IL_0023:  ldc.i4.0
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual instance bool 
+            Equals(object obj,
+                   class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1,
+               object V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_003b
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     [runtime]System.Exception
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0039
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldloc.0
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.2
+      IL_0012:  isinst     ABC/MyExn
+      IL_0017:  ldnull
+      IL_0018:  cgt.un
+      IL_001a:  brfalse.s  IL_0037
+
+      IL_001c:  ldarg.2
+      IL_001d:  stloc.3
+      IL_001e:  ldarg.0
+      IL_001f:  castclass  ABC/MyExn
+      IL_0024:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0029:  ldloc.1
+      IL_002a:  castclass  ABC/MyExn
+      IL_002f:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0034:  ceq
+      IL_0036:  ret
+
+      IL_0037:  ldc.i4.0
+      IL_0038:  ret
+
+      IL_0039:  ldc.i4.0
+      IL_003a:  ret
+
+      IL_003b:  ldarg.1
+      IL_003c:  ldnull
+      IL_003d:  cgt.un
+      IL_003f:  ldc.i4.0
+      IL_0040:  ceq
+      IL_0042:  ret
+    } 
+
+    .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0030
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002e
+
+      IL_0006:  ldarg.1
+      IL_0007:  stloc.0
+      IL_0008:  ldloc.0
+      IL_0009:  isinst     ABC/MyExn
+      IL_000e:  ldnull
+      IL_000f:  cgt.un
+      IL_0011:  brfalse.s  IL_002c
+
+      IL_0013:  ldarg.0
+      IL_0014:  castclass  ABC/MyExn
+      IL_0019:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_001e:  ldarg.1
+      IL_001f:  castclass  ABC/MyExn
+      IL_0024:  call       instance int32 ABC/MyExn::get_Data0()
+      IL_0029:  ceq
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+
+      IL_0030:  ldarg.1
+      IL_0031:  ldnull
+      IL_0032:  cgt.un
+      IL_0034:  ldc.i4.0
+      IL_0035:  ceq
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual instance bool Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     [runtime]System.Exception
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool ABC/MyExn::Equals(class [runtime]System.Exception)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Data0()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance int32 ABC/MyExn::get_Data0()
+    } 
+  } 
+
+  .class auto ansi serializable nested public A
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly string x
+    .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldarg.1
+      IL_000a:  stfld      string ABC/A::x
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance string  get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string ABC/A::x
+      IL_0006:  ret
+    } 
+
+    .property instance string X()
+    {
+      .get instance string ABC/A::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public ABC
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested public beforefieldinit Expr
+           extends [runtime]System.Object
+           implements class [runtime]System.IEquatable`1<class ABC/ABC/Expr>,
+                      [runtime]System.Collections.IStructuralEquatable,
+                      class [runtime]System.IComparable`1<class ABC/ABC/Expr>,
+                      [runtime]System.IComparable,
+                      [runtime]System.Collections.IStructuralComparable
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                           61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public static class ABC/ABC/Expr NewNum(int32 item) cil managed
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void ABC/ABC/Expr::.ctor(int32)
+        IL_0006:  ret
+      } 
+
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 0C 41 42 43 2B 41 42 43 2B 45   
+                                                                                                                                                       78 70 72 00 00 )                                  
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 ABC/ABC/Expr::item
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Tag() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  pop
+        IL_0002:  ldc.i4.0
+        IL_0003:  ret
+      } 
+
+      .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+0.8A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public strict virtual instance string ToString() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class ABC/ABC/Expr>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(class ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IComparer V_2,
+                 int32 V_3,
+                 int32 V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_002f
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002d
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.0
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.1
+        IL_001a:  ldfld      int32 ABC/ABC/Expr::item
+        IL_001f:  stloc.s    V_4
+        IL_0021:  ldloc.3
+        IL_0022:  ldloc.s    V_4
+        IL_0024:  cgt
+        IL_0026:  ldloc.3
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  clt
+        IL_002b:  sub
+        IL_002c:  ret
+
+        IL_002d:  ldc.i4.1
+        IL_002e:  ret
+
+        IL_002f:  ldarg.1
+        IL_0030:  brfalse.s  IL_0034
+
+        IL_0032:  ldc.i4.m1
+        IL_0033:  ret
+
+        IL_0034:  ldc.i4.0
+        IL_0035:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  unbox.any  ABC/ABC/Expr
+        IL_0007:  callvirt   instance int32 ABC/ABC/Expr::CompareTo(class ABC/ABC/Expr)
+        IL_000c:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance int32  CompareTo(object obj,
+                                        class [runtime]System.Collections.IComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class ABC/ABC/Expr V_2,
+                 class [runtime]System.Collections.IComparer V_3,
+                 int32 V_4,
+                 int32 V_5)
+        IL_0000:  ldarg.1
+        IL_0001:  unbox.any  ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  brfalse.s  IL_003a
+
+        IL_000a:  ldarg.1
+        IL_000b:  unbox.any  ABC/ABC/Expr
+        IL_0010:  brfalse.s  IL_0038
+
+        IL_0012:  ldarg.0
+        IL_0013:  pop
+        IL_0014:  ldarg.0
+        IL_0015:  stloc.1
+        IL_0016:  ldloc.0
+        IL_0017:  stloc.2
+        IL_0018:  ldarg.2
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.1
+        IL_001b:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0020:  stloc.s    V_4
+        IL_0022:  ldloc.2
+        IL_0023:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0028:  stloc.s    V_5
+        IL_002a:  ldloc.s    V_4
+        IL_002c:  ldloc.s    V_5
+        IL_002e:  cgt
+        IL_0030:  ldloc.s    V_4
+        IL_0032:  ldloc.s    V_5
+        IL_0034:  clt
+        IL_0036:  sub
+        IL_0037:  ret
+
+        IL_0038:  ldc.i4.1
+        IL_0039:  ret
+
+        IL_003a:  ldarg.1
+        IL_003b:  unbox.any  ABC/ABC/Expr
+        IL_0040:  brfalse.s  IL_0044
+
+        IL_0042:  ldc.i4.m1
+        IL_0043:  ret
+
+        IL_0044:  ldc.i4.0
+        IL_0045:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IEqualityComparer V_2)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0024
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldarg.0
+        IL_0006:  pop
+        IL_0007:  ldarg.0
+        IL_0008:  stloc.1
+        IL_0009:  ldc.i4.0
+        IL_000a:  stloc.0
+        IL_000b:  ldc.i4     0x9e3779b9
+        IL_0010:  ldarg.1
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  ldloc.0
+        IL_0019:  ldc.i4.6
+        IL_001a:  shl
+        IL_001b:  ldloc.0
+        IL_001c:  ldc.i4.2
+        IL_001d:  shr
+        IL_001e:  add
+        IL_001f:  add
+        IL_0020:  add
+        IL_0021:  stloc.0
+        IL_0022:  ldloc.0
+        IL_0023:  ret
+
+        IL_0024:  ldc.i4.0
+        IL_0025:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 ABC/ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance bool  Equals(object obj,
+                                    class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1,
+                 class ABC/ABC/Expr V_2,
+                 class ABC/ABC/Expr V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0029
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     ABC/ABC/Expr
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0027
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldarg.0
+        IL_0010:  pop
+        IL_0011:  ldarg.0
+        IL_0012:  stloc.2
+        IL_0013:  ldloc.1
+        IL_0014:  stloc.3
+        IL_0015:  ldarg.2
+        IL_0016:  stloc.s    V_4
+        IL_0018:  ldloc.2
+        IL_0019:  ldfld      int32 ABC/ABC/Expr::item
+        IL_001e:  ldloc.3
+        IL_001f:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0024:  ceq
+        IL_0026:  ret
+
+        IL_0027:  ldc.i4.0
+        IL_0028:  ret
+
+        IL_0029:  ldarg.1
+        IL_002a:  ldnull
+        IL_002b:  cgt.un
+        IL_002d:  ldc.i4.0
+        IL_002e:  ceq
+        IL_0030:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(class ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0,
+                 class ABC/ABC/Expr V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_001d
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_001b
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldloc.0
+        IL_000d:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 ABC/ABC/Expr::item
+        IL_0018:  ceq
+        IL_001a:  ret
+
+        IL_001b:  ldc.i4.0
+        IL_001c:  ret
+
+        IL_001d:  ldarg.1
+        IL_001e:  ldnull
+        IL_001f:  cgt.un
+        IL_0021:  ldc.i4.0
+        IL_0022:  ceq
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class ABC/ABC/Expr V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool ABC/ABC/Expr::Equals(class ABC/ABC/Expr)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Tag()
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+        .get instance int32 ABC/ABC/Expr::get_Tag()
+      } 
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 ABC/ABC/Expr::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit MyExn
+           extends [runtime]System.Exception
+           implements [runtime]System.Collections.IStructuralEquatable
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+      .field assembly int32 Data0@
+      .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 ABC/ABC/MyExn::Data0@
+        IL_000d:  ret
+      } 
+
+      .method public specialname rtspecialname instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method family specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  ldarg.2
+        IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+        IL_0008:  ret
+      } 
+
+      .method public hidebysig specialname instance int32  get_Data0() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 ABC/ABC/MyExn::Data0@
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [runtime]System.Collections.IEqualityComparer V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0023
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldc.i4     0x9e3779b9
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldarg.0
+        IL_000d:  castclass  ABC/ABC/MyExn
+        IL_0012:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0017:  ldloc.0
+        IL_0018:  ldc.i4.6
+        IL_0019:  shl
+        IL_001a:  ldloc.0
+        IL_001b:  ldc.i4.2
+        IL_001c:  shr
+        IL_001d:  add
+        IL_001e:  add
+        IL_001f:  add
+        IL_0020:  stloc.0
+        IL_0021:  ldloc.0
+        IL_0022:  ret
+
+        IL_0023:  ldc.i4.0
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 ABC/ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual instance bool 
+              Equals(object obj,
+                     class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1,
+                 object V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_003b
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     [runtime]System.Exception
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0039
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldloc.0
+        IL_0010:  stloc.2
+        IL_0011:  ldloc.2
+        IL_0012:  isinst     ABC/ABC/MyExn
+        IL_0017:  ldnull
+        IL_0018:  cgt.un
+        IL_001a:  brfalse.s  IL_0037
+
+        IL_001c:  ldarg.2
+        IL_001d:  stloc.3
+        IL_001e:  ldarg.0
+        IL_001f:  castclass  ABC/ABC/MyExn
+        IL_0024:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ldloc.1
+        IL_002a:  castclass  ABC/ABC/MyExn
+        IL_002f:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0034:  ceq
+        IL_0036:  ret
+
+        IL_0037:  ldc.i4.0
+        IL_0038:  ret
+
+        IL_0039:  ldc.i4.0
+        IL_003a:  ret
+
+        IL_003b:  ldarg.1
+        IL_003c:  ldnull
+        IL_003d:  cgt.un
+        IL_003f:  ldc.i4.0
+        IL_0040:  ceq
+        IL_0042:  ret
+      } 
+
+      .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (object V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0030
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002e
+
+        IL_0006:  ldarg.1
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  isinst     ABC/ABC/MyExn
+        IL_000e:  ldnull
+        IL_000f:  cgt.un
+        IL_0011:  brfalse.s  IL_002c
+
+        IL_0013:  ldarg.0
+        IL_0014:  castclass  ABC/ABC/MyExn
+        IL_0019:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_001e:  ldarg.1
+        IL_001f:  castclass  ABC/ABC/MyExn
+        IL_0024:  call       instance int32 ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ceq
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+
+        IL_0030:  ldarg.1
+        IL_0031:  ldnull
+        IL_0032:  cgt.un
+        IL_0034:  ldc.i4.0
+        IL_0035:  ceq
+        IL_0037:  ret
+      } 
+
+      .method public hidebysig virtual instance bool Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     [runtime]System.Exception
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool ABC/ABC/MyExn::Equals(class [runtime]System.Exception)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Data0()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+        .get instance int32 ABC/ABC/MyExn::get_Data0()
+      } 
+    } 
+
+    .class auto ansi serializable nested public A
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+      .field assembly string x
+      .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  ldarg.1
+        IL_000a:  stfld      string ABC/ABC/A::x
+        IL_000f:  ret
+      } 
+
+      .method public hidebysig specialname instance string  get_X() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      string ABC/ABC/A::x
+        IL_0006:  ret
+      } 
+
+      .property instance string X()
+      {
+        .get instance string ABC/ABC/A::get_X()
+      } 
+    } 
+
+    .method public static int32  'add'(int32 x,
+                                       int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public specialname static string get_greeting() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  ret
+    } 
+
+    .property string greeting()
+    {
+      .get string ABC/ABC::get_greeting()
+    } 
+  } 
+
+  .method public static int32  'add'(int32 x,
+                                     int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public specialname static string get_greeting() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello"
+    IL_0005:  ret
+  } 
+
+  .property string greeting()
+  {
+    .get string ABC::get_greeting()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$ABC
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOff.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOff.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOff.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOff.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOff.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOff.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOff.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOff.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOn.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOn.il.net472.debug.bsl
new file mode 100644
index 00000000000..04222059db2
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOn.il.net472.debug.bsl
@@ -0,0 +1,2351 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public auto autochar serializable sealed beforefieldinit XYZ.Expr
+       extends [runtime]System.Object
+       implements class [runtime]System.IEquatable`1<class XYZ.Expr>,
+                  [runtime]System.Collections.IStructuralEquatable,
+                  class [runtime]System.IComparable`1<class XYZ.Expr>,
+                  [runtime]System.IComparable,
+                  [runtime]System.Collections.IStructuralComparable
+{
+  .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                 61 79 28 29 2C 6E 71 7D 00 00 )                   
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+  .field assembly initonly int32 item
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static class XYZ.Expr  NewNum(int32 item) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  newobj     instance void XYZ.Expr::.ctor(int32)
+    IL_0006:  ret
+  } 
+
+  .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+  {
+    .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                            class [runtime]System.Type) = ( 01 00 60 06 00 00 08 58 59 5A 2E 45 78 70 72 00   
+                                                                                                                             00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      int32 XYZ.Expr::item
+    IL_000d:  ret
+  } 
+
+  .method public hidebysig instance int32 get_Item() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      int32 XYZ.Expr::item
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig instance int32 get_Tag() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  pop
+    IL_0002:  ldc.i4.0
+    IL_0003:  ret
+  } 
+
+  .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+0.8A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public strict virtual instance string ToString() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.Expr>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  CompareTo(class XYZ.Expr obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class [runtime]System.Collections.IComparer V_2,
+             int32 V_3,
+             int32 V_4,
+             class [runtime]System.Collections.IComparer V_5,
+             int32 V_6,
+             int32 V_7)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_003b
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_0039
+
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  stloc.0
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.0
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.1
+    IL_001a:  ldfld      int32 XYZ.Expr::item
+    IL_001f:  stloc.s    V_4
+    IL_0021:  ldloc.2
+    IL_0022:  stloc.s    V_5
+    IL_0024:  ldloc.3
+    IL_0025:  stloc.s    V_6
+    IL_0027:  ldloc.s    V_4
+    IL_0029:  stloc.s    V_7
+    IL_002b:  ldloc.s    V_6
+    IL_002d:  ldloc.s    V_7
+    IL_002f:  cgt
+    IL_0031:  ldloc.s    V_6
+    IL_0033:  ldloc.s    V_7
+    IL_0035:  clt
+    IL_0037:  sub
+    IL_0038:  ret
+
+    IL_0039:  ldc.i4.1
+    IL_003a:  ret
+
+    IL_003b:  ldarg.1
+    IL_003c:  brfalse.s  IL_0040
+
+    IL_003e:  ldc.i4.m1
+    IL_003f:  ret
+
+    IL_0040:  ldc.i4.0
+    IL_0041:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  unbox.any  XYZ.Expr
+    IL_0007:  callvirt   instance int32 XYZ.Expr::CompareTo(class XYZ.Expr)
+    IL_000c:  ret
+  } 
+
+  .method public hidebysig virtual final 
+          instance int32  CompareTo(object obj,
+                                    class [runtime]System.Collections.IComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class XYZ.Expr V_2,
+             class [runtime]System.Collections.IComparer V_3,
+             int32 V_4,
+             int32 V_5,
+             class [runtime]System.Collections.IComparer V_6,
+             int32 V_7,
+             int32 V_8)
+    IL_0000:  ldarg.1
+    IL_0001:  unbox.any  XYZ.Expr
+    IL_0006:  stloc.0
+    IL_0007:  ldarg.0
+    IL_0008:  brfalse.s  IL_0045
+
+    IL_000a:  ldarg.1
+    IL_000b:  unbox.any  XYZ.Expr
+    IL_0010:  brfalse.s  IL_0043
+
+    IL_0012:  ldarg.0
+    IL_0013:  pop
+    IL_0014:  ldarg.0
+    IL_0015:  stloc.1
+    IL_0016:  ldloc.0
+    IL_0017:  stloc.2
+    IL_0018:  ldarg.2
+    IL_0019:  stloc.3
+    IL_001a:  ldloc.1
+    IL_001b:  ldfld      int32 XYZ.Expr::item
+    IL_0020:  stloc.s    V_4
+    IL_0022:  ldloc.2
+    IL_0023:  ldfld      int32 XYZ.Expr::item
+    IL_0028:  stloc.s    V_5
+    IL_002a:  ldloc.3
+    IL_002b:  stloc.s    V_6
+    IL_002d:  ldloc.s    V_4
+    IL_002f:  stloc.s    V_7
+    IL_0031:  ldloc.s    V_5
+    IL_0033:  stloc.s    V_8
+    IL_0035:  ldloc.s    V_7
+    IL_0037:  ldloc.s    V_8
+    IL_0039:  cgt
+    IL_003b:  ldloc.s    V_7
+    IL_003d:  ldloc.s    V_8
+    IL_003f:  clt
+    IL_0041:  sub
+    IL_0042:  ret
+
+    IL_0043:  ldc.i4.1
+    IL_0044:  ret
+
+    IL_0045:  ldarg.1
+    IL_0046:  unbox.any  XYZ.Expr
+    IL_004b:  brfalse.s  IL_004f
+
+    IL_004d:  ldc.i4.m1
+    IL_004e:  ret
+
+    IL_004f:  ldc.i4.0
+    IL_0050:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             class XYZ.Expr V_1,
+             class [runtime]System.Collections.IEqualityComparer V_2,
+             int32 V_3,
+             class [runtime]System.Collections.IEqualityComparer V_4)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0029
+
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.0
+    IL_0005:  ldarg.0
+    IL_0006:  pop
+    IL_0007:  ldarg.0
+    IL_0008:  stloc.1
+    IL_0009:  ldc.i4.0
+    IL_000a:  stloc.0
+    IL_000b:  ldc.i4     0x9e3779b9
+    IL_0010:  ldarg.1
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.1
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.2
+    IL_001a:  stloc.s    V_4
+    IL_001c:  ldloc.3
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.6
+    IL_001f:  shl
+    IL_0020:  ldloc.0
+    IL_0021:  ldc.i4.2
+    IL_0022:  shr
+    IL_0023:  add
+    IL_0024:  add
+    IL_0025:  add
+    IL_0026:  stloc.0
+    IL_0027:  ldloc.0
+    IL_0028:  ret
+
+    IL_0029:  ldc.i4.0
+    IL_002a:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0006:  callvirt   instance int32 XYZ.Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+    IL_000b:  ret
+  } 
+
+  .method public hidebysig virtual final 
+          instance bool  Equals(object obj,
+                                class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class XYZ.Expr V_2,
+             class XYZ.Expr V_3,
+             class [runtime]System.Collections.IEqualityComparer V_4,
+             int32 V_5,
+             int32 V_6,
+             class [runtime]System.Collections.IEqualityComparer V_7)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0035
+
+    IL_0003:  ldarg.1
+    IL_0004:  isinst     XYZ.Expr
+    IL_0009:  stloc.0
+    IL_000a:  ldloc.0
+    IL_000b:  brfalse.s  IL_0033
+
+    IL_000d:  ldloc.0
+    IL_000e:  stloc.1
+    IL_000f:  ldarg.0
+    IL_0010:  pop
+    IL_0011:  ldarg.0
+    IL_0012:  stloc.2
+    IL_0013:  ldloc.1
+    IL_0014:  stloc.3
+    IL_0015:  ldarg.2
+    IL_0016:  stloc.s    V_4
+    IL_0018:  ldloc.2
+    IL_0019:  ldfld      int32 XYZ.Expr::item
+    IL_001e:  stloc.s    V_5
+    IL_0020:  ldloc.3
+    IL_0021:  ldfld      int32 XYZ.Expr::item
+    IL_0026:  stloc.s    V_6
+    IL_0028:  ldloc.s    V_4
+    IL_002a:  stloc.s    V_7
+    IL_002c:  ldloc.s    V_5
+    IL_002e:  ldloc.s    V_6
+    IL_0030:  ceq
+    IL_0032:  ret
+
+    IL_0033:  ldc.i4.0
+    IL_0034:  ret
+
+    IL_0035:  ldarg.1
+    IL_0036:  ldnull
+    IL_0037:  cgt.un
+    IL_0039:  ldc.i4.0
+    IL_003a:  ceq
+    IL_003c:  ret
+  } 
+
+  .method public hidebysig virtual final instance bool  Equals(class XYZ.Expr obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_001d
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_001b
+
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  stloc.0
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  ldloc.0
+    IL_000d:  ldfld      int32 XYZ.Expr::item
+    IL_0012:  ldloc.1
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  ceq
+    IL_001a:  ret
+
+    IL_001b:  ldc.i4.0
+    IL_001c:  ret
+
+    IL_001d:  ldarg.1
+    IL_001e:  ldnull
+    IL_001f:  cgt.un
+    IL_0021:  ldc.i4.0
+    IL_0022:  ceq
+    IL_0024:  ret
+  } 
+
+  .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  isinst     XYZ.Expr
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_0012
+
+    IL_000a:  ldarg.0
+    IL_000b:  ldloc.0
+    IL_000c:  callvirt   instance bool XYZ.Expr::Equals(class XYZ.Expr)
+    IL_0011:  ret
+
+    IL_0012:  ldc.i4.0
+    IL_0013:  ret
+  } 
+
+  .property instance int32 Tag()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .get instance int32 XYZ.Expr::get_Tag()
+  } 
+  .property instance int32 Item()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32,
+                                                                                                int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance int32 XYZ.Expr::get_Item()
+  } 
+} 
+
+.class public auto ansi serializable beforefieldinit XYZ.MyExn
+       extends [runtime]System.Exception
+       implements [runtime]System.Collections.IStructuralEquatable
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+  .field assembly int32 Data0@
+  .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      int32 XYZ.MyExn::Data0@
+    IL_000d:  ret
+  } 
+
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+    IL_0006:  ret
+  } 
+
+  .method family specialname rtspecialname 
+          instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                               valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  ldarg.2
+    IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                         valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+    IL_0008:  ret
+  } 
+
+  .method public hidebysig specialname instance int32 get_Data0() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      int32 XYZ.MyExn::Data0@
+    IL_0006:  ret
+  } 
+
+  .method public strict virtual instance string get_Message() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.MyExn>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.MyExn,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             class [runtime]System.Collections.IEqualityComparer V_1,
+             int32 V_2,
+             class [runtime]System.Collections.IEqualityComparer V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0027
+
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.0
+    IL_0005:  ldc.i4     0x9e3779b9
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  ldarg.0
+    IL_000d:  castclass  XYZ.MyExn
+    IL_0012:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0017:  stloc.2
+    IL_0018:  ldloc.1
+    IL_0019:  stloc.3
+    IL_001a:  ldloc.2
+    IL_001b:  ldloc.0
+    IL_001c:  ldc.i4.6
+    IL_001d:  shl
+    IL_001e:  ldloc.0
+    IL_001f:  ldc.i4.2
+    IL_0020:  shr
+    IL_0021:  add
+    IL_0022:  add
+    IL_0023:  add
+    IL_0024:  stloc.0
+    IL_0025:  ldloc.0
+    IL_0026:  ret
+
+    IL_0027:  ldc.i4.0
+    IL_0028:  ret
+  } 
+
+  .method public hidebysig virtual instance int32 GetHashCode() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0006:  callvirt   instance int32 XYZ.MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+    IL_000b:  ret
+  } 
+
+  .method public hidebysig virtual instance bool 
+          Equals(object obj,
+                 class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0,
+             class [runtime]System.Exception V_1,
+             object V_2,
+             class [runtime]System.Collections.IEqualityComparer V_3,
+             int32 V_4,
+             int32 V_5,
+             class [runtime]System.Collections.IEqualityComparer V_6)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0046
+
+    IL_0003:  ldarg.1
+    IL_0004:  isinst     [runtime]System.Exception
+    IL_0009:  stloc.0
+    IL_000a:  ldloc.0
+    IL_000b:  brfalse.s  IL_0044
+
+    IL_000d:  ldloc.0
+    IL_000e:  stloc.1
+    IL_000f:  ldloc.0
+    IL_0010:  stloc.2
+    IL_0011:  ldloc.2
+    IL_0012:  isinst     XYZ.MyExn
+    IL_0017:  ldnull
+    IL_0018:  cgt.un
+    IL_001a:  brfalse.s  IL_0042
+
+    IL_001c:  ldarg.2
+    IL_001d:  stloc.3
+    IL_001e:  ldarg.0
+    IL_001f:  castclass  XYZ.MyExn
+    IL_0024:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0029:  stloc.s    V_4
+    IL_002b:  ldloc.1
+    IL_002c:  castclass  XYZ.MyExn
+    IL_0031:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0036:  stloc.s    V_5
+    IL_0038:  ldloc.3
+    IL_0039:  stloc.s    V_6
+    IL_003b:  ldloc.s    V_4
+    IL_003d:  ldloc.s    V_5
+    IL_003f:  ceq
+    IL_0041:  ret
+
+    IL_0042:  ldc.i4.0
+    IL_0043:  ret
+
+    IL_0044:  ldc.i4.0
+    IL_0045:  ret
+
+    IL_0046:  ldarg.1
+    IL_0047:  ldnull
+    IL_0048:  cgt.un
+    IL_004a:  ldc.i4.0
+    IL_004b:  ceq
+    IL_004d:  ret
+  } 
+
+  .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (object V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0030
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_002e
+
+    IL_0006:  ldarg.1
+    IL_0007:  stloc.0
+    IL_0008:  ldloc.0
+    IL_0009:  isinst     XYZ.MyExn
+    IL_000e:  ldnull
+    IL_000f:  cgt.un
+    IL_0011:  brfalse.s  IL_002c
+
+    IL_0013:  ldarg.0
+    IL_0014:  castclass  XYZ.MyExn
+    IL_0019:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_001e:  ldarg.1
+    IL_001f:  castclass  XYZ.MyExn
+    IL_0024:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0029:  ceq
+    IL_002b:  ret
+
+    IL_002c:  ldc.i4.0
+    IL_002d:  ret
+
+    IL_002e:  ldc.i4.0
+    IL_002f:  ret
+
+    IL_0030:  ldarg.1
+    IL_0031:  ldnull
+    IL_0032:  cgt.un
+    IL_0034:  ldc.i4.0
+    IL_0035:  ceq
+    IL_0037:  ret
+  } 
+
+  .method public hidebysig virtual instance bool Equals(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  isinst     [runtime]System.Exception
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_0012
+
+    IL_000a:  ldarg.0
+    IL_000b:  ldloc.0
+    IL_000c:  callvirt   instance bool XYZ.MyExn::Equals(class [runtime]System.Exception)
+    IL_0011:  ret
+
+    IL_0012:  ldc.i4.0
+    IL_0013:  ret
+  } 
+
+  .property instance int32 Data0()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+    .get instance int32 XYZ.MyExn::get_Data0()
+  } 
+} 
+
+.class public auto ansi serializable XYZ.A
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .field assembly string x
+  .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  ldarg.1
+    IL_000a:  stfld      string XYZ.A::x
+    IL_000f:  ret
+  } 
+
+  .method public hidebysig specialname instance string get_X() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      string XYZ.A::x
+    IL_0006:  ret
+  } 
+
+  .property instance string X()
+  {
+    .get instance string XYZ.A::get_X()
+  } 
+} 
+
+.class public abstract auto ansi sealed XYZ.ABC
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Expr
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class XYZ.ABC/Expr>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class XYZ.ABC/Expr>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                   61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field assembly initonly int32 item
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public static class XYZ.ABC/Expr NewNum(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void XYZ.ABC/Expr::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+    {
+      .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                              class [runtime]System.Type) = ( 01 00 60 06 00 00 0C 58 59 5A 2E 41 42 43 2B 45   
+                                                                                                                               78 70 72 00 00 )                                  
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 XYZ.ABC/Expr::item
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Item() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/Expr>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class XYZ.ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4,
+               class [runtime]System.Collections.IComparer V_5,
+               int32 V_6,
+               int32 V_7)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_003b
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_0039
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.0
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.1
+      IL_001a:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.2
+      IL_0022:  stloc.s    V_5
+      IL_0024:  ldloc.3
+      IL_0025:  stloc.s    V_6
+      IL_0027:  ldloc.s    V_4
+      IL_0029:  stloc.s    V_7
+      IL_002b:  ldloc.s    V_6
+      IL_002d:  ldloc.s    V_7
+      IL_002f:  cgt
+      IL_0031:  ldloc.s    V_6
+      IL_0033:  ldloc.s    V_7
+      IL_0035:  clt
+      IL_0037:  sub
+      IL_0038:  ret
+
+      IL_0039:  ldc.i4.1
+      IL_003a:  ret
+
+      IL_003b:  ldarg.1
+      IL_003c:  brfalse.s  IL_0040
+
+      IL_003e:  ldc.i4.m1
+      IL_003f:  ret
+
+      IL_0040:  ldc.i4.0
+      IL_0041:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  XYZ.ABC/Expr
+      IL_0007:  callvirt   instance int32 XYZ.ABC/Expr::CompareTo(class XYZ.ABC/Expr)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class XYZ.ABC/Expr V_2,
+               class [runtime]System.Collections.IComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IComparer V_6,
+               int32 V_7,
+               int32 V_8)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  XYZ.ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_0045
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  XYZ.ABC/Expr
+      IL_0010:  brfalse.s  IL_0043
+
+      IL_0012:  ldarg.0
+      IL_0013:  pop
+      IL_0014:  ldarg.0
+      IL_0015:  stloc.1
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  ldarg.2
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.1
+      IL_001b:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0020:  stloc.s    V_4
+      IL_0022:  ldloc.2
+      IL_0023:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0028:  stloc.s    V_5
+      IL_002a:  ldloc.3
+      IL_002b:  stloc.s    V_6
+      IL_002d:  ldloc.s    V_4
+      IL_002f:  stloc.s    V_7
+      IL_0031:  ldloc.s    V_5
+      IL_0033:  stloc.s    V_8
+      IL_0035:  ldloc.s    V_7
+      IL_0037:  ldloc.s    V_8
+      IL_0039:  cgt
+      IL_003b:  ldloc.s    V_7
+      IL_003d:  ldloc.s    V_8
+      IL_003f:  clt
+      IL_0041:  sub
+      IL_0042:  ret
+
+      IL_0043:  ldc.i4.1
+      IL_0044:  ret
+
+      IL_0045:  ldarg.1
+      IL_0046:  unbox.any  XYZ.ABC/Expr
+      IL_004b:  brfalse.s  IL_004f
+
+      IL_004d:  ldc.i4.m1
+      IL_004e:  ret
+
+      IL_004f:  ldc.i4.0
+      IL_0050:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class XYZ.ABC/Expr V_1,
+               class [runtime]System.Collections.IEqualityComparer V_2,
+               int32 V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0029
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldarg.0
+      IL_0008:  stloc.1
+      IL_0009:  ldc.i4.0
+      IL_000a:  stloc.0
+      IL_000b:  ldc.i4     0x9e3779b9
+      IL_0010:  ldarg.1
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.2
+      IL_001a:  stloc.s    V_4
+      IL_001c:  ldloc.3
+      IL_001d:  ldloc.0
+      IL_001e:  ldc.i4.6
+      IL_001f:  shl
+      IL_0020:  ldloc.0
+      IL_0021:  ldc.i4.2
+      IL_0022:  shr
+      IL_0023:  add
+      IL_0024:  add
+      IL_0025:  add
+      IL_0026:  stloc.0
+      IL_0027:  ldloc.0
+      IL_0028:  ret
+
+      IL_0029:  ldc.i4.0
+      IL_002a:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 XYZ.ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class XYZ.ABC/Expr V_2,
+               class XYZ.ABC/Expr V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4,
+               int32 V_5,
+               int32 V_6,
+               class [runtime]System.Collections.IEqualityComparer V_7)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0035
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     XYZ.ABC/Expr
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0033
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  pop
+      IL_0011:  ldarg.0
+      IL_0012:  stloc.2
+      IL_0013:  ldloc.1
+      IL_0014:  stloc.3
+      IL_0015:  ldarg.2
+      IL_0016:  stloc.s    V_4
+      IL_0018:  ldloc.2
+      IL_0019:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_001e:  stloc.s    V_5
+      IL_0020:  ldloc.3
+      IL_0021:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0026:  stloc.s    V_6
+      IL_0028:  ldloc.s    V_4
+      IL_002a:  stloc.s    V_7
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  ldloc.s    V_6
+      IL_0030:  ceq
+      IL_0032:  ret
+
+      IL_0033:  ldc.i4.0
+      IL_0034:  ret
+
+      IL_0035:  ldarg.1
+      IL_0036:  ldnull
+      IL_0037:  cgt.un
+      IL_0039:  ldc.i4.0
+      IL_003a:  ceq
+      IL_003c:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class XYZ.ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001d
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001b
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldloc.0
+      IL_000d:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  ceq
+      IL_001a:  ret
+
+      IL_001b:  ldc.i4.0
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  ldnull
+      IL_001f:  cgt.un
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     XYZ.ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool XYZ.ABC/Expr::Equals(class XYZ.ABC/Expr)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 XYZ.ABC/Expr::get_Tag()
+    } 
+    .property instance int32 Item()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .get instance int32 XYZ.ABC/Expr::get_Item()
+    } 
+  } 
+
+  .class auto ansi serializable nested public beforefieldinit MyExn
+         extends [runtime]System.Exception
+         implements [runtime]System.Collections.IStructuralEquatable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+    .field assembly int32 Data0@
+    .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 XYZ.ABC/MyExn::Data0@
+      IL_000d:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method family specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  ldarg.2
+      IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                           valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_Data0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 XYZ.ABC/MyExn::Data0@
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string get_Message() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/MyExn>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/MyExn,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1,
+               int32 V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0027
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldc.i4     0x9e3779b9
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  castclass  XYZ.ABC/MyExn
+      IL_0012:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0017:  stloc.2
+      IL_0018:  ldloc.1
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.2
+      IL_001b:  ldloc.0
+      IL_001c:  ldc.i4.6
+      IL_001d:  shl
+      IL_001e:  ldloc.0
+      IL_001f:  ldc.i4.2
+      IL_0020:  shr
+      IL_0021:  add
+      IL_0022:  add
+      IL_0023:  add
+      IL_0024:  stloc.0
+      IL_0025:  ldloc.0
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 XYZ.ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual instance bool 
+            Equals(object obj,
+                   class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1,
+               object V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IEqualityComparer V_6)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0046
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     [runtime]System.Exception
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0044
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldloc.0
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.2
+      IL_0012:  isinst     XYZ.ABC/MyExn
+      IL_0017:  ldnull
+      IL_0018:  cgt.un
+      IL_001a:  brfalse.s  IL_0042
+
+      IL_001c:  ldarg.2
+      IL_001d:  stloc.3
+      IL_001e:  ldarg.0
+      IL_001f:  castclass  XYZ.ABC/MyExn
+      IL_0024:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0029:  stloc.s    V_4
+      IL_002b:  ldloc.1
+      IL_002c:  castclass  XYZ.ABC/MyExn
+      IL_0031:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0036:  stloc.s    V_5
+      IL_0038:  ldloc.3
+      IL_0039:  stloc.s    V_6
+      IL_003b:  ldloc.s    V_4
+      IL_003d:  ldloc.s    V_5
+      IL_003f:  ceq
+      IL_0041:  ret
+
+      IL_0042:  ldc.i4.0
+      IL_0043:  ret
+
+      IL_0044:  ldc.i4.0
+      IL_0045:  ret
+
+      IL_0046:  ldarg.1
+      IL_0047:  ldnull
+      IL_0048:  cgt.un
+      IL_004a:  ldc.i4.0
+      IL_004b:  ceq
+      IL_004d:  ret
+    } 
+
+    .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0030
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002e
+
+      IL_0006:  ldarg.1
+      IL_0007:  stloc.0
+      IL_0008:  ldloc.0
+      IL_0009:  isinst     XYZ.ABC/MyExn
+      IL_000e:  ldnull
+      IL_000f:  cgt.un
+      IL_0011:  brfalse.s  IL_002c
+
+      IL_0013:  ldarg.0
+      IL_0014:  castclass  XYZ.ABC/MyExn
+      IL_0019:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_001e:  ldarg.1
+      IL_001f:  castclass  XYZ.ABC/MyExn
+      IL_0024:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0029:  ceq
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+
+      IL_0030:  ldarg.1
+      IL_0031:  ldnull
+      IL_0032:  cgt.un
+      IL_0034:  ldc.i4.0
+      IL_0035:  ceq
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual instance bool Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     [runtime]System.Exception
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool XYZ.ABC/MyExn::Equals(class [runtime]System.Exception)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Data0()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance int32 XYZ.ABC/MyExn::get_Data0()
+    } 
+  } 
+
+  .class auto ansi serializable nested public A
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly string x
+    .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldarg.1
+      IL_000a:  stfld      string XYZ.ABC/A::x
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance string  get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string XYZ.ABC/A::x
+      IL_0006:  ret
+    } 
+
+    .property instance string X()
+    {
+      .get instance string XYZ.ABC/A::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public ABC
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested public beforefieldinit Expr
+           extends [runtime]System.Object
+           implements class [runtime]System.IEquatable`1<class XYZ.ABC/ABC/Expr>,
+                      [runtime]System.Collections.IStructuralEquatable,
+                      class [runtime]System.IComparable`1<class XYZ.ABC/ABC/Expr>,
+                      [runtime]System.IComparable,
+                      [runtime]System.Collections.IStructuralComparable
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                     61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public static class XYZ.ABC/ABC/Expr NewNum(int32 item) cil managed
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void XYZ.ABC/ABC/Expr::.ctor(int32)
+        IL_0006:  ret
+      } 
+
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 10 58 59 5A 2E 41 42 43 2B 41   
+                                                                                                                                 42 43 2B 45 78 70 72 00 00 )                      
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Tag() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  pop
+        IL_0002:  ldc.i4.0
+        IL_0003:  ret
+      } 
+
+      .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+0.8A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public strict virtual instance string ToString() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/ABC/Expr>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(class XYZ.ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IComparer V_2,
+                 int32 V_3,
+                 int32 V_4,
+                 class [runtime]System.Collections.IComparer V_5,
+                 int32 V_6,
+                 int32 V_7)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_003b
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_0039
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.0
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.1
+        IL_001a:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_001f:  stloc.s    V_4
+        IL_0021:  ldloc.2
+        IL_0022:  stloc.s    V_5
+        IL_0024:  ldloc.3
+        IL_0025:  stloc.s    V_6
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  stloc.s    V_7
+        IL_002b:  ldloc.s    V_6
+        IL_002d:  ldloc.s    V_7
+        IL_002f:  cgt
+        IL_0031:  ldloc.s    V_6
+        IL_0033:  ldloc.s    V_7
+        IL_0035:  clt
+        IL_0037:  sub
+        IL_0038:  ret
+
+        IL_0039:  ldc.i4.1
+        IL_003a:  ret
+
+        IL_003b:  ldarg.1
+        IL_003c:  brfalse.s  IL_0040
+
+        IL_003e:  ldc.i4.m1
+        IL_003f:  ret
+
+        IL_0040:  ldc.i4.0
+        IL_0041:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0007:  callvirt   instance int32 XYZ.ABC/ABC/Expr::CompareTo(class XYZ.ABC/ABC/Expr)
+        IL_000c:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance int32  CompareTo(object obj,
+                                        class [runtime]System.Collections.IComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class XYZ.ABC/ABC/Expr V_2,
+                 class [runtime]System.Collections.IComparer V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class [runtime]System.Collections.IComparer V_6,
+                 int32 V_7,
+                 int32 V_8)
+        IL_0000:  ldarg.1
+        IL_0001:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  brfalse.s  IL_0045
+
+        IL_000a:  ldarg.1
+        IL_000b:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0010:  brfalse.s  IL_0043
+
+        IL_0012:  ldarg.0
+        IL_0013:  pop
+        IL_0014:  ldarg.0
+        IL_0015:  stloc.1
+        IL_0016:  ldloc.0
+        IL_0017:  stloc.2
+        IL_0018:  ldarg.2
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.1
+        IL_001b:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0020:  stloc.s    V_4
+        IL_0022:  ldloc.2
+        IL_0023:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0028:  stloc.s    V_5
+        IL_002a:  ldloc.3
+        IL_002b:  stloc.s    V_6
+        IL_002d:  ldloc.s    V_4
+        IL_002f:  stloc.s    V_7
+        IL_0031:  ldloc.s    V_5
+        IL_0033:  stloc.s    V_8
+        IL_0035:  ldloc.s    V_7
+        IL_0037:  ldloc.s    V_8
+        IL_0039:  cgt
+        IL_003b:  ldloc.s    V_7
+        IL_003d:  ldloc.s    V_8
+        IL_003f:  clt
+        IL_0041:  sub
+        IL_0042:  ret
+
+        IL_0043:  ldc.i4.1
+        IL_0044:  ret
+
+        IL_0045:  ldarg.1
+        IL_0046:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_004b:  brfalse.s  IL_004f
+
+        IL_004d:  ldc.i4.m1
+        IL_004e:  ret
+
+        IL_004f:  ldc.i4.0
+        IL_0050:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IEqualityComparer V_2,
+                 int32 V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0029
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldarg.0
+        IL_0006:  pop
+        IL_0007:  ldarg.0
+        IL_0008:  stloc.1
+        IL_0009:  ldc.i4.0
+        IL_000a:  stloc.0
+        IL_000b:  ldc.i4     0x9e3779b9
+        IL_0010:  ldarg.1
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.2
+        IL_001a:  stloc.s    V_4
+        IL_001c:  ldloc.3
+        IL_001d:  ldloc.0
+        IL_001e:  ldc.i4.6
+        IL_001f:  shl
+        IL_0020:  ldloc.0
+        IL_0021:  ldc.i4.2
+        IL_0022:  shr
+        IL_0023:  add
+        IL_0024:  add
+        IL_0025:  add
+        IL_0026:  stloc.0
+        IL_0027:  ldloc.0
+        IL_0028:  ret
+
+        IL_0029:  ldc.i4.0
+        IL_002a:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 XYZ.ABC/ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance bool  Equals(object obj,
+                                    class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class XYZ.ABC/ABC/Expr V_2,
+                 class XYZ.ABC/ABC/Expr V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4,
+                 int32 V_5,
+                 int32 V_6,
+                 class [runtime]System.Collections.IEqualityComparer V_7)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0035
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     XYZ.ABC/ABC/Expr
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0033
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldarg.0
+        IL_0010:  pop
+        IL_0011:  ldarg.0
+        IL_0012:  stloc.2
+        IL_0013:  ldloc.1
+        IL_0014:  stloc.3
+        IL_0015:  ldarg.2
+        IL_0016:  stloc.s    V_4
+        IL_0018:  ldloc.2
+        IL_0019:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_001e:  stloc.s    V_5
+        IL_0020:  ldloc.3
+        IL_0021:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0026:  stloc.s    V_6
+        IL_0028:  ldloc.s    V_4
+        IL_002a:  stloc.s    V_7
+        IL_002c:  ldloc.s    V_5
+        IL_002e:  ldloc.s    V_6
+        IL_0030:  ceq
+        IL_0032:  ret
+
+        IL_0033:  ldc.i4.0
+        IL_0034:  ret
+
+        IL_0035:  ldarg.1
+        IL_0036:  ldnull
+        IL_0037:  cgt.un
+        IL_0039:  ldc.i4.0
+        IL_003a:  ceq
+        IL_003c:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(class XYZ.ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_001d
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_001b
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldloc.0
+        IL_000d:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  ceq
+        IL_001a:  ret
+
+        IL_001b:  ldc.i4.0
+        IL_001c:  ret
+
+        IL_001d:  ldarg.1
+        IL_001e:  ldnull
+        IL_001f:  cgt.un
+        IL_0021:  ldc.i4.0
+        IL_0022:  ceq
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     XYZ.ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool XYZ.ABC/ABC/Expr::Equals(class XYZ.ABC/ABC/Expr)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Tag()
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/Expr::get_Tag()
+      } 
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/Expr::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit MyExn
+           extends [runtime]System.Exception
+           implements [runtime]System.Collections.IStructuralEquatable
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+      .field assembly int32 Data0@
+      .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 XYZ.ABC/ABC/MyExn::Data0@
+        IL_000d:  ret
+      } 
+
+      .method public specialname rtspecialname instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method family specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  ldarg.2
+        IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                             valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+        IL_0008:  ret
+      } 
+
+      .method public hidebysig specialname instance int32  get_Data0() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 XYZ.ABC/ABC/MyExn::Data0@
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance string get_Message() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/ABC/MyExn>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/MyExn,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [runtime]System.Collections.IEqualityComparer V_1,
+                 int32 V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0027
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldc.i4     0x9e3779b9
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldarg.0
+        IL_000d:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0012:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0017:  stloc.2
+        IL_0018:  ldloc.1
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.2
+        IL_001b:  ldloc.0
+        IL_001c:  ldc.i4.6
+        IL_001d:  shl
+        IL_001e:  ldloc.0
+        IL_001f:  ldc.i4.2
+        IL_0020:  shr
+        IL_0021:  add
+        IL_0022:  add
+        IL_0023:  add
+        IL_0024:  stloc.0
+        IL_0025:  ldloc.0
+        IL_0026:  ret
+
+        IL_0027:  ldc.i4.0
+        IL_0028:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 XYZ.ABC/ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual instance bool 
+              Equals(object obj,
+                     class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1,
+                 object V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class [runtime]System.Collections.IEqualityComparer V_6)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0046
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     [runtime]System.Exception
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0044
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldloc.0
+        IL_0010:  stloc.2
+        IL_0011:  ldloc.2
+        IL_0012:  isinst     XYZ.ABC/ABC/MyExn
+        IL_0017:  ldnull
+        IL_0018:  cgt.un
+        IL_001a:  brfalse.s  IL_0042
+
+        IL_001c:  ldarg.2
+        IL_001d:  stloc.3
+        IL_001e:  ldarg.0
+        IL_001f:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0024:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0029:  stloc.s    V_4
+        IL_002b:  ldloc.1
+        IL_002c:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0031:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0036:  stloc.s    V_5
+        IL_0038:  ldloc.3
+        IL_0039:  stloc.s    V_6
+        IL_003b:  ldloc.s    V_4
+        IL_003d:  ldloc.s    V_5
+        IL_003f:  ceq
+        IL_0041:  ret
+
+        IL_0042:  ldc.i4.0
+        IL_0043:  ret
+
+        IL_0044:  ldc.i4.0
+        IL_0045:  ret
+
+        IL_0046:  ldarg.1
+        IL_0047:  ldnull
+        IL_0048:  cgt.un
+        IL_004a:  ldc.i4.0
+        IL_004b:  ceq
+        IL_004d:  ret
+      } 
+
+      .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (object V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0030
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002e
+
+        IL_0006:  ldarg.1
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  isinst     XYZ.ABC/ABC/MyExn
+        IL_000e:  ldnull
+        IL_000f:  cgt.un
+        IL_0011:  brfalse.s  IL_002c
+
+        IL_0013:  ldarg.0
+        IL_0014:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0019:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_001e:  ldarg.1
+        IL_001f:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0024:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ceq
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+
+        IL_0030:  ldarg.1
+        IL_0031:  ldnull
+        IL_0032:  cgt.un
+        IL_0034:  ldc.i4.0
+        IL_0035:  ceq
+        IL_0037:  ret
+      } 
+
+      .method public hidebysig virtual instance bool Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     [runtime]System.Exception
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool XYZ.ABC/ABC/MyExn::Equals(class [runtime]System.Exception)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Data0()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+      } 
+    } 
+
+    .class auto ansi serializable nested public A
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+      .field assembly string x
+      .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  ldarg.1
+        IL_000a:  stfld      string XYZ.ABC/ABC/A::x
+        IL_000f:  ret
+      } 
+
+      .method public hidebysig specialname instance string  get_X() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      string XYZ.ABC/ABC/A::x
+        IL_0006:  ret
+      } 
+
+      .property instance string X()
+      {
+        .get instance string XYZ.ABC/ABC/A::get_X()
+      } 
+    } 
+
+    .method public static int32  'add'(int32 x,
+                                       int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public specialname static string get_greeting() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  ret
+    } 
+
+    .property string greeting()
+    {
+      .get string XYZ.ABC/ABC::get_greeting()
+    } 
+  } 
+
+  .method public static int32  'add'(int32 x,
+                                     int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public specialname static string get_greeting() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello"
+    IL_0005:  ret
+  } 
+
+  .property string greeting()
+  {
+    .get string XYZ.ABC::get_greeting()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+.class private auto ansi serializable sealed System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+       extends [runtime]System.Enum
+{
+  .custom instance void [runtime]System.FlagsAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field public specialname rtspecialname int32 value__
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes All = int32(0xFFFFFFFF)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes None = int32(0x00000000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicParameterlessConstructor = int32(0x00000001)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicConstructors = int32(0x00000003)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicConstructors = int32(0x00000004)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicMethods = int32(0x00000008)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicMethods = int32(0x00000010)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicFields = int32(0x00000020)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicFields = int32(0x00000040)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicNestedTypes = int32(0x00000080)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicNestedTypes = int32(0x00000100)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicProperties = int32(0x00000200)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicProperties = int32(0x00000400)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicEvents = int32(0x00000800)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicEvents = int32(0x00001000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes Interfaces = int32(0x00002000)
+} 
+
+.class private auto ansi beforefieldinit System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute
+       extends [runtime]System.Attribute
+{
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private class [runtime]System.Type Type@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public specialname rtspecialname 
+          instance void  .ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType,
+                               class [runtime]System.Type Type) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Attribute::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_000d:  ldarg.0
+    IL_000e:  ldarg.2
+    IL_000f:  stfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0014:  ret
+  } 
+
+  .method public hidebysig specialname instance class [runtime]System.Type get_Type() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes get_MemberType() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_0006:  ret
+  } 
+
+  .property instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+          MemberType()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_MemberType()
+  } 
+  .property instance class [runtime]System.Type
+          Type()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_Type()
+  } 
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOn.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOn.il.net472.release.bsl
new file mode 100644
index 00000000000..ebdd0bcea99
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOn.il.net472.release.bsl
@@ -0,0 +1,2207 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public auto autochar serializable sealed beforefieldinit XYZ.Expr
+       extends [runtime]System.Object
+       implements class [runtime]System.IEquatable`1<class XYZ.Expr>,
+                  [runtime]System.Collections.IStructuralEquatable,
+                  class [runtime]System.IComparable`1<class XYZ.Expr>,
+                  [runtime]System.IComparable,
+                  [runtime]System.Collections.IStructuralComparable
+{
+  .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                 61 79 28 29 2C 6E 71 7D 00 00 )                   
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+  .field assembly initonly int32 item
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static class XYZ.Expr  NewNum(int32 item) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  newobj     instance void XYZ.Expr::.ctor(int32)
+    IL_0006:  ret
+  } 
+
+  .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+  {
+    .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                            class [runtime]System.Type) = ( 01 00 60 06 00 00 08 58 59 5A 2E 45 78 70 72 00   
+                                                                                                                             00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      int32 XYZ.Expr::item
+    IL_000d:  ret
+  } 
+
+  .method public hidebysig instance int32 get_Item() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      int32 XYZ.Expr::item
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig instance int32 get_Tag() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  pop
+    IL_0002:  ldc.i4.0
+    IL_0003:  ret
+  } 
+
+  .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+0.8A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public strict virtual instance string ToString() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.Expr>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  CompareTo(class XYZ.Expr obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class [runtime]System.Collections.IComparer V_2,
+             int32 V_3,
+             int32 V_4)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_002f
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_002d
+
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  stloc.0
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.0
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.1
+    IL_001a:  ldfld      int32 XYZ.Expr::item
+    IL_001f:  stloc.s    V_4
+    IL_0021:  ldloc.3
+    IL_0022:  ldloc.s    V_4
+    IL_0024:  cgt
+    IL_0026:  ldloc.3
+    IL_0027:  ldloc.s    V_4
+    IL_0029:  clt
+    IL_002b:  sub
+    IL_002c:  ret
+
+    IL_002d:  ldc.i4.1
+    IL_002e:  ret
+
+    IL_002f:  ldarg.1
+    IL_0030:  brfalse.s  IL_0034
+
+    IL_0032:  ldc.i4.m1
+    IL_0033:  ret
+
+    IL_0034:  ldc.i4.0
+    IL_0035:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  unbox.any  XYZ.Expr
+    IL_0007:  callvirt   instance int32 XYZ.Expr::CompareTo(class XYZ.Expr)
+    IL_000c:  ret
+  } 
+
+  .method public hidebysig virtual final 
+          instance int32  CompareTo(object obj,
+                                    class [runtime]System.Collections.IComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class XYZ.Expr V_2,
+             class [runtime]System.Collections.IComparer V_3,
+             int32 V_4,
+             int32 V_5)
+    IL_0000:  ldarg.1
+    IL_0001:  unbox.any  XYZ.Expr
+    IL_0006:  stloc.0
+    IL_0007:  ldarg.0
+    IL_0008:  brfalse.s  IL_003a
+
+    IL_000a:  ldarg.1
+    IL_000b:  unbox.any  XYZ.Expr
+    IL_0010:  brfalse.s  IL_0038
+
+    IL_0012:  ldarg.0
+    IL_0013:  pop
+    IL_0014:  ldarg.0
+    IL_0015:  stloc.1
+    IL_0016:  ldloc.0
+    IL_0017:  stloc.2
+    IL_0018:  ldarg.2
+    IL_0019:  stloc.3
+    IL_001a:  ldloc.1
+    IL_001b:  ldfld      int32 XYZ.Expr::item
+    IL_0020:  stloc.s    V_4
+    IL_0022:  ldloc.2
+    IL_0023:  ldfld      int32 XYZ.Expr::item
+    IL_0028:  stloc.s    V_5
+    IL_002a:  ldloc.s    V_4
+    IL_002c:  ldloc.s    V_5
+    IL_002e:  cgt
+    IL_0030:  ldloc.s    V_4
+    IL_0032:  ldloc.s    V_5
+    IL_0034:  clt
+    IL_0036:  sub
+    IL_0037:  ret
+
+    IL_0038:  ldc.i4.1
+    IL_0039:  ret
+
+    IL_003a:  ldarg.1
+    IL_003b:  unbox.any  XYZ.Expr
+    IL_0040:  brfalse.s  IL_0044
+
+    IL_0042:  ldc.i4.m1
+    IL_0043:  ret
+
+    IL_0044:  ldc.i4.0
+    IL_0045:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             class XYZ.Expr V_1,
+             class [runtime]System.Collections.IEqualityComparer V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0024
+
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.0
+    IL_0005:  ldarg.0
+    IL_0006:  pop
+    IL_0007:  ldarg.0
+    IL_0008:  stloc.1
+    IL_0009:  ldc.i4.0
+    IL_000a:  stloc.0
+    IL_000b:  ldc.i4     0x9e3779b9
+    IL_0010:  ldarg.1
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.1
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  ldloc.0
+    IL_0019:  ldc.i4.6
+    IL_001a:  shl
+    IL_001b:  ldloc.0
+    IL_001c:  ldc.i4.2
+    IL_001d:  shr
+    IL_001e:  add
+    IL_001f:  add
+    IL_0020:  add
+    IL_0021:  stloc.0
+    IL_0022:  ldloc.0
+    IL_0023:  ret
+
+    IL_0024:  ldc.i4.0
+    IL_0025:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0006:  callvirt   instance int32 XYZ.Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+    IL_000b:  ret
+  } 
+
+  .method public hidebysig virtual final 
+          instance bool  Equals(object obj,
+                                class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class XYZ.Expr V_2,
+             class XYZ.Expr V_3,
+             class [runtime]System.Collections.IEqualityComparer V_4)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0029
+
+    IL_0003:  ldarg.1
+    IL_0004:  isinst     XYZ.Expr
+    IL_0009:  stloc.0
+    IL_000a:  ldloc.0
+    IL_000b:  brfalse.s  IL_0027
+
+    IL_000d:  ldloc.0
+    IL_000e:  stloc.1
+    IL_000f:  ldarg.0
+    IL_0010:  pop
+    IL_0011:  ldarg.0
+    IL_0012:  stloc.2
+    IL_0013:  ldloc.1
+    IL_0014:  stloc.3
+    IL_0015:  ldarg.2
+    IL_0016:  stloc.s    V_4
+    IL_0018:  ldloc.2
+    IL_0019:  ldfld      int32 XYZ.Expr::item
+    IL_001e:  ldloc.3
+    IL_001f:  ldfld      int32 XYZ.Expr::item
+    IL_0024:  ceq
+    IL_0026:  ret
+
+    IL_0027:  ldc.i4.0
+    IL_0028:  ret
+
+    IL_0029:  ldarg.1
+    IL_002a:  ldnull
+    IL_002b:  cgt.un
+    IL_002d:  ldc.i4.0
+    IL_002e:  ceq
+    IL_0030:  ret
+  } 
+
+  .method public hidebysig virtual final instance bool  Equals(class XYZ.Expr obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_001d
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_001b
+
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  stloc.0
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  ldloc.0
+    IL_000d:  ldfld      int32 XYZ.Expr::item
+    IL_0012:  ldloc.1
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  ceq
+    IL_001a:  ret
+
+    IL_001b:  ldc.i4.0
+    IL_001c:  ret
+
+    IL_001d:  ldarg.1
+    IL_001e:  ldnull
+    IL_001f:  cgt.un
+    IL_0021:  ldc.i4.0
+    IL_0022:  ceq
+    IL_0024:  ret
+  } 
+
+  .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  isinst     XYZ.Expr
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_0012
+
+    IL_000a:  ldarg.0
+    IL_000b:  ldloc.0
+    IL_000c:  callvirt   instance bool XYZ.Expr::Equals(class XYZ.Expr)
+    IL_0011:  ret
+
+    IL_0012:  ldc.i4.0
+    IL_0013:  ret
+  } 
+
+  .property instance int32 Tag()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .get instance int32 XYZ.Expr::get_Tag()
+  } 
+  .property instance int32 Item()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32,
+                                                                                                int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance int32 XYZ.Expr::get_Item()
+  } 
+} 
+
+.class public auto ansi serializable beforefieldinit XYZ.MyExn
+       extends [runtime]System.Exception
+       implements [runtime]System.Collections.IStructuralEquatable
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+  .field assembly int32 Data0@
+  .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      int32 XYZ.MyExn::Data0@
+    IL_000d:  ret
+  } 
+
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+    IL_0006:  ret
+  } 
+
+  .method family specialname rtspecialname 
+          instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                               valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  ldarg.2
+    IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                         valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+    IL_0008:  ret
+  } 
+
+  .method public hidebysig specialname instance int32 get_Data0() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      int32 XYZ.MyExn::Data0@
+    IL_0006:  ret
+  } 
+
+  .method public strict virtual instance string get_Message() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.MyExn>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.MyExn,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             class [runtime]System.Collections.IEqualityComparer V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0023
+
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.0
+    IL_0005:  ldc.i4     0x9e3779b9
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  ldarg.0
+    IL_000d:  castclass  XYZ.MyExn
+    IL_0012:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0017:  ldloc.0
+    IL_0018:  ldc.i4.6
+    IL_0019:  shl
+    IL_001a:  ldloc.0
+    IL_001b:  ldc.i4.2
+    IL_001c:  shr
+    IL_001d:  add
+    IL_001e:  add
+    IL_001f:  add
+    IL_0020:  stloc.0
+    IL_0021:  ldloc.0
+    IL_0022:  ret
+
+    IL_0023:  ldc.i4.0
+    IL_0024:  ret
+  } 
+
+  .method public hidebysig virtual instance int32 GetHashCode() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0006:  callvirt   instance int32 XYZ.MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+    IL_000b:  ret
+  } 
+
+  .method public hidebysig virtual instance bool 
+          Equals(object obj,
+                 class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0,
+             class [runtime]System.Exception V_1,
+             object V_2,
+             class [runtime]System.Collections.IEqualityComparer V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_003b
+
+    IL_0003:  ldarg.1
+    IL_0004:  isinst     [runtime]System.Exception
+    IL_0009:  stloc.0
+    IL_000a:  ldloc.0
+    IL_000b:  brfalse.s  IL_0039
+
+    IL_000d:  ldloc.0
+    IL_000e:  stloc.1
+    IL_000f:  ldloc.0
+    IL_0010:  stloc.2
+    IL_0011:  ldloc.2
+    IL_0012:  isinst     XYZ.MyExn
+    IL_0017:  ldnull
+    IL_0018:  cgt.un
+    IL_001a:  brfalse.s  IL_0037
+
+    IL_001c:  ldarg.2
+    IL_001d:  stloc.3
+    IL_001e:  ldarg.0
+    IL_001f:  castclass  XYZ.MyExn
+    IL_0024:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0029:  ldloc.1
+    IL_002a:  castclass  XYZ.MyExn
+    IL_002f:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0034:  ceq
+    IL_0036:  ret
+
+    IL_0037:  ldc.i4.0
+    IL_0038:  ret
+
+    IL_0039:  ldc.i4.0
+    IL_003a:  ret
+
+    IL_003b:  ldarg.1
+    IL_003c:  ldnull
+    IL_003d:  cgt.un
+    IL_003f:  ldc.i4.0
+    IL_0040:  ceq
+    IL_0042:  ret
+  } 
+
+  .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (object V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0030
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_002e
+
+    IL_0006:  ldarg.1
+    IL_0007:  stloc.0
+    IL_0008:  ldloc.0
+    IL_0009:  isinst     XYZ.MyExn
+    IL_000e:  ldnull
+    IL_000f:  cgt.un
+    IL_0011:  brfalse.s  IL_002c
+
+    IL_0013:  ldarg.0
+    IL_0014:  castclass  XYZ.MyExn
+    IL_0019:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_001e:  ldarg.1
+    IL_001f:  castclass  XYZ.MyExn
+    IL_0024:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0029:  ceq
+    IL_002b:  ret
+
+    IL_002c:  ldc.i4.0
+    IL_002d:  ret
+
+    IL_002e:  ldc.i4.0
+    IL_002f:  ret
+
+    IL_0030:  ldarg.1
+    IL_0031:  ldnull
+    IL_0032:  cgt.un
+    IL_0034:  ldc.i4.0
+    IL_0035:  ceq
+    IL_0037:  ret
+  } 
+
+  .method public hidebysig virtual instance bool Equals(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  isinst     [runtime]System.Exception
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_0012
+
+    IL_000a:  ldarg.0
+    IL_000b:  ldloc.0
+    IL_000c:  callvirt   instance bool XYZ.MyExn::Equals(class [runtime]System.Exception)
+    IL_0011:  ret
+
+    IL_0012:  ldc.i4.0
+    IL_0013:  ret
+  } 
+
+  .property instance int32 Data0()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+    .get instance int32 XYZ.MyExn::get_Data0()
+  } 
+} 
+
+.class public auto ansi serializable XYZ.A
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .field assembly string x
+  .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  ldarg.1
+    IL_000a:  stfld      string XYZ.A::x
+    IL_000f:  ret
+  } 
+
+  .method public hidebysig specialname instance string get_X() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      string XYZ.A::x
+    IL_0006:  ret
+  } 
+
+  .property instance string X()
+  {
+    .get instance string XYZ.A::get_X()
+  } 
+} 
+
+.class public abstract auto ansi sealed XYZ.ABC
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Expr
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class XYZ.ABC/Expr>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class XYZ.ABC/Expr>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                   61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field assembly initonly int32 item
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public static class XYZ.ABC/Expr NewNum(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void XYZ.ABC/Expr::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+    {
+      .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                              class [runtime]System.Type) = ( 01 00 60 06 00 00 0C 58 59 5A 2E 41 42 43 2B 45   
+                                                                                                                               78 70 72 00 00 )                                  
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 XYZ.ABC/Expr::item
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Item() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/Expr>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class XYZ.ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_002f
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002d
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.0
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.1
+      IL_001a:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.3
+      IL_0022:  ldloc.s    V_4
+      IL_0024:  cgt
+      IL_0026:  ldloc.3
+      IL_0027:  ldloc.s    V_4
+      IL_0029:  clt
+      IL_002b:  sub
+      IL_002c:  ret
+
+      IL_002d:  ldc.i4.1
+      IL_002e:  ret
+
+      IL_002f:  ldarg.1
+      IL_0030:  brfalse.s  IL_0034
+
+      IL_0032:  ldc.i4.m1
+      IL_0033:  ret
+
+      IL_0034:  ldc.i4.0
+      IL_0035:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  XYZ.ABC/Expr
+      IL_0007:  callvirt   instance int32 XYZ.ABC/Expr::CompareTo(class XYZ.ABC/Expr)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class XYZ.ABC/Expr V_2,
+               class [runtime]System.Collections.IComparer V_3,
+               int32 V_4,
+               int32 V_5)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  XYZ.ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_003a
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  XYZ.ABC/Expr
+      IL_0010:  brfalse.s  IL_0038
+
+      IL_0012:  ldarg.0
+      IL_0013:  pop
+      IL_0014:  ldarg.0
+      IL_0015:  stloc.1
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  ldarg.2
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.1
+      IL_001b:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0020:  stloc.s    V_4
+      IL_0022:  ldloc.2
+      IL_0023:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0028:  stloc.s    V_5
+      IL_002a:  ldloc.s    V_4
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  cgt
+      IL_0030:  ldloc.s    V_4
+      IL_0032:  ldloc.s    V_5
+      IL_0034:  clt
+      IL_0036:  sub
+      IL_0037:  ret
+
+      IL_0038:  ldc.i4.1
+      IL_0039:  ret
+
+      IL_003a:  ldarg.1
+      IL_003b:  unbox.any  XYZ.ABC/Expr
+      IL_0040:  brfalse.s  IL_0044
+
+      IL_0042:  ldc.i4.m1
+      IL_0043:  ret
+
+      IL_0044:  ldc.i4.0
+      IL_0045:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class XYZ.ABC/Expr V_1,
+               class [runtime]System.Collections.IEqualityComparer V_2)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0024
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldarg.0
+      IL_0008:  stloc.1
+      IL_0009:  ldc.i4.0
+      IL_000a:  stloc.0
+      IL_000b:  ldc.i4     0x9e3779b9
+      IL_0010:  ldarg.1
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  ldloc.0
+      IL_0019:  ldc.i4.6
+      IL_001a:  shl
+      IL_001b:  ldloc.0
+      IL_001c:  ldc.i4.2
+      IL_001d:  shr
+      IL_001e:  add
+      IL_001f:  add
+      IL_0020:  add
+      IL_0021:  stloc.0
+      IL_0022:  ldloc.0
+      IL_0023:  ret
+
+      IL_0024:  ldc.i4.0
+      IL_0025:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 XYZ.ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class XYZ.ABC/Expr V_2,
+               class XYZ.ABC/Expr V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0029
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     XYZ.ABC/Expr
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0027
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  pop
+      IL_0011:  ldarg.0
+      IL_0012:  stloc.2
+      IL_0013:  ldloc.1
+      IL_0014:  stloc.3
+      IL_0015:  ldarg.2
+      IL_0016:  stloc.s    V_4
+      IL_0018:  ldloc.2
+      IL_0019:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_001e:  ldloc.3
+      IL_001f:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0024:  ceq
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+
+      IL_0029:  ldarg.1
+      IL_002a:  ldnull
+      IL_002b:  cgt.un
+      IL_002d:  ldc.i4.0
+      IL_002e:  ceq
+      IL_0030:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class XYZ.ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001d
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001b
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldloc.0
+      IL_000d:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  ceq
+      IL_001a:  ret
+
+      IL_001b:  ldc.i4.0
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  ldnull
+      IL_001f:  cgt.un
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     XYZ.ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool XYZ.ABC/Expr::Equals(class XYZ.ABC/Expr)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 XYZ.ABC/Expr::get_Tag()
+    } 
+    .property instance int32 Item()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .get instance int32 XYZ.ABC/Expr::get_Item()
+    } 
+  } 
+
+  .class auto ansi serializable nested public beforefieldinit MyExn
+         extends [runtime]System.Exception
+         implements [runtime]System.Collections.IStructuralEquatable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+    .field assembly int32 Data0@
+    .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 XYZ.ABC/MyExn::Data0@
+      IL_000d:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method family specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  ldarg.2
+      IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                           valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_Data0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 XYZ.ABC/MyExn::Data0@
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string get_Message() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/MyExn>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/MyExn,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0023
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldc.i4     0x9e3779b9
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  castclass  XYZ.ABC/MyExn
+      IL_0012:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0017:  ldloc.0
+      IL_0018:  ldc.i4.6
+      IL_0019:  shl
+      IL_001a:  ldloc.0
+      IL_001b:  ldc.i4.2
+      IL_001c:  shr
+      IL_001d:  add
+      IL_001e:  add
+      IL_001f:  add
+      IL_0020:  stloc.0
+      IL_0021:  ldloc.0
+      IL_0022:  ret
+
+      IL_0023:  ldc.i4.0
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 XYZ.ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual instance bool 
+            Equals(object obj,
+                   class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1,
+               object V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_003b
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     [runtime]System.Exception
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0039
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldloc.0
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.2
+      IL_0012:  isinst     XYZ.ABC/MyExn
+      IL_0017:  ldnull
+      IL_0018:  cgt.un
+      IL_001a:  brfalse.s  IL_0037
+
+      IL_001c:  ldarg.2
+      IL_001d:  stloc.3
+      IL_001e:  ldarg.0
+      IL_001f:  castclass  XYZ.ABC/MyExn
+      IL_0024:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0029:  ldloc.1
+      IL_002a:  castclass  XYZ.ABC/MyExn
+      IL_002f:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0034:  ceq
+      IL_0036:  ret
+
+      IL_0037:  ldc.i4.0
+      IL_0038:  ret
+
+      IL_0039:  ldc.i4.0
+      IL_003a:  ret
+
+      IL_003b:  ldarg.1
+      IL_003c:  ldnull
+      IL_003d:  cgt.un
+      IL_003f:  ldc.i4.0
+      IL_0040:  ceq
+      IL_0042:  ret
+    } 
+
+    .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0030
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002e
+
+      IL_0006:  ldarg.1
+      IL_0007:  stloc.0
+      IL_0008:  ldloc.0
+      IL_0009:  isinst     XYZ.ABC/MyExn
+      IL_000e:  ldnull
+      IL_000f:  cgt.un
+      IL_0011:  brfalse.s  IL_002c
+
+      IL_0013:  ldarg.0
+      IL_0014:  castclass  XYZ.ABC/MyExn
+      IL_0019:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_001e:  ldarg.1
+      IL_001f:  castclass  XYZ.ABC/MyExn
+      IL_0024:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0029:  ceq
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+
+      IL_0030:  ldarg.1
+      IL_0031:  ldnull
+      IL_0032:  cgt.un
+      IL_0034:  ldc.i4.0
+      IL_0035:  ceq
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual instance bool Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     [runtime]System.Exception
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool XYZ.ABC/MyExn::Equals(class [runtime]System.Exception)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Data0()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance int32 XYZ.ABC/MyExn::get_Data0()
+    } 
+  } 
+
+  .class auto ansi serializable nested public A
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly string x
+    .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldarg.1
+      IL_000a:  stfld      string XYZ.ABC/A::x
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance string  get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string XYZ.ABC/A::x
+      IL_0006:  ret
+    } 
+
+    .property instance string X()
+    {
+      .get instance string XYZ.ABC/A::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public ABC
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested public beforefieldinit Expr
+           extends [runtime]System.Object
+           implements class [runtime]System.IEquatable`1<class XYZ.ABC/ABC/Expr>,
+                      [runtime]System.Collections.IStructuralEquatable,
+                      class [runtime]System.IComparable`1<class XYZ.ABC/ABC/Expr>,
+                      [runtime]System.IComparable,
+                      [runtime]System.Collections.IStructuralComparable
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                     61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public static class XYZ.ABC/ABC/Expr NewNum(int32 item) cil managed
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void XYZ.ABC/ABC/Expr::.ctor(int32)
+        IL_0006:  ret
+      } 
+
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 10 58 59 5A 2E 41 42 43 2B 41   
+                                                                                                                                 42 43 2B 45 78 70 72 00 00 )                      
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Tag() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  pop
+        IL_0002:  ldc.i4.0
+        IL_0003:  ret
+      } 
+
+      .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+0.8A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public strict virtual instance string ToString() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/ABC/Expr>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(class XYZ.ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IComparer V_2,
+                 int32 V_3,
+                 int32 V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_002f
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002d
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.0
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.1
+        IL_001a:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_001f:  stloc.s    V_4
+        IL_0021:  ldloc.3
+        IL_0022:  ldloc.s    V_4
+        IL_0024:  cgt
+        IL_0026:  ldloc.3
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  clt
+        IL_002b:  sub
+        IL_002c:  ret
+
+        IL_002d:  ldc.i4.1
+        IL_002e:  ret
+
+        IL_002f:  ldarg.1
+        IL_0030:  brfalse.s  IL_0034
+
+        IL_0032:  ldc.i4.m1
+        IL_0033:  ret
+
+        IL_0034:  ldc.i4.0
+        IL_0035:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0007:  callvirt   instance int32 XYZ.ABC/ABC/Expr::CompareTo(class XYZ.ABC/ABC/Expr)
+        IL_000c:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance int32  CompareTo(object obj,
+                                        class [runtime]System.Collections.IComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class XYZ.ABC/ABC/Expr V_2,
+                 class [runtime]System.Collections.IComparer V_3,
+                 int32 V_4,
+                 int32 V_5)
+        IL_0000:  ldarg.1
+        IL_0001:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  brfalse.s  IL_003a
+
+        IL_000a:  ldarg.1
+        IL_000b:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0010:  brfalse.s  IL_0038
+
+        IL_0012:  ldarg.0
+        IL_0013:  pop
+        IL_0014:  ldarg.0
+        IL_0015:  stloc.1
+        IL_0016:  ldloc.0
+        IL_0017:  stloc.2
+        IL_0018:  ldarg.2
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.1
+        IL_001b:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0020:  stloc.s    V_4
+        IL_0022:  ldloc.2
+        IL_0023:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0028:  stloc.s    V_5
+        IL_002a:  ldloc.s    V_4
+        IL_002c:  ldloc.s    V_5
+        IL_002e:  cgt
+        IL_0030:  ldloc.s    V_4
+        IL_0032:  ldloc.s    V_5
+        IL_0034:  clt
+        IL_0036:  sub
+        IL_0037:  ret
+
+        IL_0038:  ldc.i4.1
+        IL_0039:  ret
+
+        IL_003a:  ldarg.1
+        IL_003b:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0040:  brfalse.s  IL_0044
+
+        IL_0042:  ldc.i4.m1
+        IL_0043:  ret
+
+        IL_0044:  ldc.i4.0
+        IL_0045:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IEqualityComparer V_2)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0024
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldarg.0
+        IL_0006:  pop
+        IL_0007:  ldarg.0
+        IL_0008:  stloc.1
+        IL_0009:  ldc.i4.0
+        IL_000a:  stloc.0
+        IL_000b:  ldc.i4     0x9e3779b9
+        IL_0010:  ldarg.1
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  ldloc.0
+        IL_0019:  ldc.i4.6
+        IL_001a:  shl
+        IL_001b:  ldloc.0
+        IL_001c:  ldc.i4.2
+        IL_001d:  shr
+        IL_001e:  add
+        IL_001f:  add
+        IL_0020:  add
+        IL_0021:  stloc.0
+        IL_0022:  ldloc.0
+        IL_0023:  ret
+
+        IL_0024:  ldc.i4.0
+        IL_0025:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 XYZ.ABC/ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance bool  Equals(object obj,
+                                    class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class XYZ.ABC/ABC/Expr V_2,
+                 class XYZ.ABC/ABC/Expr V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0029
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     XYZ.ABC/ABC/Expr
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0027
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldarg.0
+        IL_0010:  pop
+        IL_0011:  ldarg.0
+        IL_0012:  stloc.2
+        IL_0013:  ldloc.1
+        IL_0014:  stloc.3
+        IL_0015:  ldarg.2
+        IL_0016:  stloc.s    V_4
+        IL_0018:  ldloc.2
+        IL_0019:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_001e:  ldloc.3
+        IL_001f:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0024:  ceq
+        IL_0026:  ret
+
+        IL_0027:  ldc.i4.0
+        IL_0028:  ret
+
+        IL_0029:  ldarg.1
+        IL_002a:  ldnull
+        IL_002b:  cgt.un
+        IL_002d:  ldc.i4.0
+        IL_002e:  ceq
+        IL_0030:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(class XYZ.ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_001d
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_001b
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldloc.0
+        IL_000d:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  ceq
+        IL_001a:  ret
+
+        IL_001b:  ldc.i4.0
+        IL_001c:  ret
+
+        IL_001d:  ldarg.1
+        IL_001e:  ldnull
+        IL_001f:  cgt.un
+        IL_0021:  ldc.i4.0
+        IL_0022:  ceq
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     XYZ.ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool XYZ.ABC/ABC/Expr::Equals(class XYZ.ABC/ABC/Expr)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Tag()
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/Expr::get_Tag()
+      } 
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/Expr::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit MyExn
+           extends [runtime]System.Exception
+           implements [runtime]System.Collections.IStructuralEquatable
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+      .field assembly int32 Data0@
+      .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 XYZ.ABC/ABC/MyExn::Data0@
+        IL_000d:  ret
+      } 
+
+      .method public specialname rtspecialname instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method family specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  ldarg.2
+        IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                             valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+        IL_0008:  ret
+      } 
+
+      .method public hidebysig specialname instance int32  get_Data0() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 XYZ.ABC/ABC/MyExn::Data0@
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance string get_Message() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/ABC/MyExn>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/MyExn,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [runtime]System.Collections.IEqualityComparer V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0023
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldc.i4     0x9e3779b9
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldarg.0
+        IL_000d:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0012:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0017:  ldloc.0
+        IL_0018:  ldc.i4.6
+        IL_0019:  shl
+        IL_001a:  ldloc.0
+        IL_001b:  ldc.i4.2
+        IL_001c:  shr
+        IL_001d:  add
+        IL_001e:  add
+        IL_001f:  add
+        IL_0020:  stloc.0
+        IL_0021:  ldloc.0
+        IL_0022:  ret
+
+        IL_0023:  ldc.i4.0
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 XYZ.ABC/ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual instance bool 
+              Equals(object obj,
+                     class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1,
+                 object V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_003b
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     [runtime]System.Exception
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0039
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldloc.0
+        IL_0010:  stloc.2
+        IL_0011:  ldloc.2
+        IL_0012:  isinst     XYZ.ABC/ABC/MyExn
+        IL_0017:  ldnull
+        IL_0018:  cgt.un
+        IL_001a:  brfalse.s  IL_0037
+
+        IL_001c:  ldarg.2
+        IL_001d:  stloc.3
+        IL_001e:  ldarg.0
+        IL_001f:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0024:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ldloc.1
+        IL_002a:  castclass  XYZ.ABC/ABC/MyExn
+        IL_002f:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0034:  ceq
+        IL_0036:  ret
+
+        IL_0037:  ldc.i4.0
+        IL_0038:  ret
+
+        IL_0039:  ldc.i4.0
+        IL_003a:  ret
+
+        IL_003b:  ldarg.1
+        IL_003c:  ldnull
+        IL_003d:  cgt.un
+        IL_003f:  ldc.i4.0
+        IL_0040:  ceq
+        IL_0042:  ret
+      } 
+
+      .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (object V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0030
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002e
+
+        IL_0006:  ldarg.1
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  isinst     XYZ.ABC/ABC/MyExn
+        IL_000e:  ldnull
+        IL_000f:  cgt.un
+        IL_0011:  brfalse.s  IL_002c
+
+        IL_0013:  ldarg.0
+        IL_0014:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0019:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_001e:  ldarg.1
+        IL_001f:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0024:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ceq
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+
+        IL_0030:  ldarg.1
+        IL_0031:  ldnull
+        IL_0032:  cgt.un
+        IL_0034:  ldc.i4.0
+        IL_0035:  ceq
+        IL_0037:  ret
+      } 
+
+      .method public hidebysig virtual instance bool Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     [runtime]System.Exception
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool XYZ.ABC/ABC/MyExn::Equals(class [runtime]System.Exception)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Data0()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+      } 
+    } 
+
+    .class auto ansi serializable nested public A
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+      .field assembly string x
+      .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  ldarg.1
+        IL_000a:  stfld      string XYZ.ABC/ABC/A::x
+        IL_000f:  ret
+      } 
+
+      .method public hidebysig specialname instance string  get_X() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      string XYZ.ABC/ABC/A::x
+        IL_0006:  ret
+      } 
+
+      .property instance string X()
+      {
+        .get instance string XYZ.ABC/ABC/A::get_X()
+      } 
+    } 
+
+    .method public static int32  'add'(int32 x,
+                                       int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public specialname static string get_greeting() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  ret
+    } 
+
+    .property string greeting()
+    {
+      .get string XYZ.ABC/ABC::get_greeting()
+    } 
+  } 
+
+  .method public static int32  'add'(int32 x,
+                                     int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public specialname static string get_greeting() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello"
+    IL_0005:  ret
+  } 
+
+  .property string greeting()
+  {
+    .get string XYZ.ABC::get_greeting()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+.class private auto ansi serializable sealed System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+       extends [runtime]System.Enum
+{
+  .custom instance void [runtime]System.FlagsAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field public specialname rtspecialname int32 value__
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes All = int32(0xFFFFFFFF)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes None = int32(0x00000000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicParameterlessConstructor = int32(0x00000001)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicConstructors = int32(0x00000003)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicConstructors = int32(0x00000004)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicMethods = int32(0x00000008)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicMethods = int32(0x00000010)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicFields = int32(0x00000020)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicFields = int32(0x00000040)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicNestedTypes = int32(0x00000080)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicNestedTypes = int32(0x00000100)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicProperties = int32(0x00000200)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicProperties = int32(0x00000400)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicEvents = int32(0x00000800)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicEvents = int32(0x00001000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes Interfaces = int32(0x00002000)
+} 
+
+.class private auto ansi beforefieldinit System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute
+       extends [runtime]System.Attribute
+{
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private class [runtime]System.Type Type@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public specialname rtspecialname 
+          instance void  .ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType,
+                               class [runtime]System.Type Type) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Attribute::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_000d:  ldarg.0
+    IL_000e:  ldarg.2
+    IL_000f:  stfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0014:  ret
+  } 
+
+  .method public hidebysig specialname instance class [runtime]System.Type get_Type() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes get_MemberType() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_0006:  ret
+  } 
+
+  .property instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+          MemberType()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_MemberType()
+  } 
+  .property instance class [runtime]System.Type
+          Type()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_Type()
+  } 
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOn.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOn.il.netcore.debug.bsl
new file mode 100644
index 00000000000..91efa2ba6b5
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOn.il.netcore.debug.bsl
@@ -0,0 +1,2259 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public auto autochar serializable sealed beforefieldinit XYZ.Expr
+       extends [runtime]System.Object
+       implements class [runtime]System.IEquatable`1<class XYZ.Expr>,
+                  [runtime]System.Collections.IStructuralEquatable,
+                  class [runtime]System.IComparable`1<class XYZ.Expr>,
+                  [runtime]System.IComparable,
+                  [runtime]System.Collections.IStructuralComparable
+{
+  .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                       61 79 28 29 2C 6E 71 7D 00 00 )                   
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+  .field assembly initonly int32 item
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static class XYZ.Expr  NewNum(int32 item) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  newobj     instance void XYZ.Expr::.ctor(int32)
+    IL_0006:  ret
+  } 
+
+  .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+  {
+    .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                            class [runtime]System.Type) = ( 01 00 60 06 00 00 08 58 59 5A 2E 45 78 70 72 00   
+                                                                                                                                                   00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      int32 XYZ.Expr::item
+    IL_000d:  ret
+  } 
+
+  .method public hidebysig instance int32 get_Item() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      int32 XYZ.Expr::item
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig instance int32 get_Tag() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  pop
+    IL_0002:  ldc.i4.0
+    IL_0003:  ret
+  } 
+
+  .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+0.8A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public strict virtual instance string ToString() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.Expr>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  CompareTo(class XYZ.Expr obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class [runtime]System.Collections.IComparer V_2,
+             int32 V_3,
+             int32 V_4,
+             class [runtime]System.Collections.IComparer V_5,
+             int32 V_6,
+             int32 V_7)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_003b
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_0039
+
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  stloc.0
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.0
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.1
+    IL_001a:  ldfld      int32 XYZ.Expr::item
+    IL_001f:  stloc.s    V_4
+    IL_0021:  ldloc.2
+    IL_0022:  stloc.s    V_5
+    IL_0024:  ldloc.3
+    IL_0025:  stloc.s    V_6
+    IL_0027:  ldloc.s    V_4
+    IL_0029:  stloc.s    V_7
+    IL_002b:  ldloc.s    V_6
+    IL_002d:  ldloc.s    V_7
+    IL_002f:  cgt
+    IL_0031:  ldloc.s    V_6
+    IL_0033:  ldloc.s    V_7
+    IL_0035:  clt
+    IL_0037:  sub
+    IL_0038:  ret
+
+    IL_0039:  ldc.i4.1
+    IL_003a:  ret
+
+    IL_003b:  ldarg.1
+    IL_003c:  brfalse.s  IL_0040
+
+    IL_003e:  ldc.i4.m1
+    IL_003f:  ret
+
+    IL_0040:  ldc.i4.0
+    IL_0041:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  unbox.any  XYZ.Expr
+    IL_0007:  callvirt   instance int32 XYZ.Expr::CompareTo(class XYZ.Expr)
+    IL_000c:  ret
+  } 
+
+  .method public hidebysig virtual final 
+          instance int32  CompareTo(object obj,
+                                    class [runtime]System.Collections.IComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class XYZ.Expr V_2,
+             class [runtime]System.Collections.IComparer V_3,
+             int32 V_4,
+             int32 V_5,
+             class [runtime]System.Collections.IComparer V_6,
+             int32 V_7,
+             int32 V_8)
+    IL_0000:  ldarg.1
+    IL_0001:  unbox.any  XYZ.Expr
+    IL_0006:  stloc.0
+    IL_0007:  ldarg.0
+    IL_0008:  brfalse.s  IL_0045
+
+    IL_000a:  ldarg.1
+    IL_000b:  unbox.any  XYZ.Expr
+    IL_0010:  brfalse.s  IL_0043
+
+    IL_0012:  ldarg.0
+    IL_0013:  pop
+    IL_0014:  ldarg.0
+    IL_0015:  stloc.1
+    IL_0016:  ldloc.0
+    IL_0017:  stloc.2
+    IL_0018:  ldarg.2
+    IL_0019:  stloc.3
+    IL_001a:  ldloc.1
+    IL_001b:  ldfld      int32 XYZ.Expr::item
+    IL_0020:  stloc.s    V_4
+    IL_0022:  ldloc.2
+    IL_0023:  ldfld      int32 XYZ.Expr::item
+    IL_0028:  stloc.s    V_5
+    IL_002a:  ldloc.3
+    IL_002b:  stloc.s    V_6
+    IL_002d:  ldloc.s    V_4
+    IL_002f:  stloc.s    V_7
+    IL_0031:  ldloc.s    V_5
+    IL_0033:  stloc.s    V_8
+    IL_0035:  ldloc.s    V_7
+    IL_0037:  ldloc.s    V_8
+    IL_0039:  cgt
+    IL_003b:  ldloc.s    V_7
+    IL_003d:  ldloc.s    V_8
+    IL_003f:  clt
+    IL_0041:  sub
+    IL_0042:  ret
+
+    IL_0043:  ldc.i4.1
+    IL_0044:  ret
+
+    IL_0045:  ldarg.1
+    IL_0046:  unbox.any  XYZ.Expr
+    IL_004b:  brfalse.s  IL_004f
+
+    IL_004d:  ldc.i4.m1
+    IL_004e:  ret
+
+    IL_004f:  ldc.i4.0
+    IL_0050:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             class XYZ.Expr V_1,
+             class [runtime]System.Collections.IEqualityComparer V_2,
+             int32 V_3,
+             class [runtime]System.Collections.IEqualityComparer V_4)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0029
+
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.0
+    IL_0005:  ldarg.0
+    IL_0006:  pop
+    IL_0007:  ldarg.0
+    IL_0008:  stloc.1
+    IL_0009:  ldc.i4.0
+    IL_000a:  stloc.0
+    IL_000b:  ldc.i4     0x9e3779b9
+    IL_0010:  ldarg.1
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.1
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.2
+    IL_001a:  stloc.s    V_4
+    IL_001c:  ldloc.3
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.6
+    IL_001f:  shl
+    IL_0020:  ldloc.0
+    IL_0021:  ldc.i4.2
+    IL_0022:  shr
+    IL_0023:  add
+    IL_0024:  add
+    IL_0025:  add
+    IL_0026:  stloc.0
+    IL_0027:  ldloc.0
+    IL_0028:  ret
+
+    IL_0029:  ldc.i4.0
+    IL_002a:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0006:  callvirt   instance int32 XYZ.Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+    IL_000b:  ret
+  } 
+
+  .method public hidebysig virtual final 
+          instance bool  Equals(object obj,
+                                class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class XYZ.Expr V_2,
+             class XYZ.Expr V_3,
+             class [runtime]System.Collections.IEqualityComparer V_4,
+             int32 V_5,
+             int32 V_6,
+             class [runtime]System.Collections.IEqualityComparer V_7)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0035
+
+    IL_0003:  ldarg.1
+    IL_0004:  isinst     XYZ.Expr
+    IL_0009:  stloc.0
+    IL_000a:  ldloc.0
+    IL_000b:  brfalse.s  IL_0033
+
+    IL_000d:  ldloc.0
+    IL_000e:  stloc.1
+    IL_000f:  ldarg.0
+    IL_0010:  pop
+    IL_0011:  ldarg.0
+    IL_0012:  stloc.2
+    IL_0013:  ldloc.1
+    IL_0014:  stloc.3
+    IL_0015:  ldarg.2
+    IL_0016:  stloc.s    V_4
+    IL_0018:  ldloc.2
+    IL_0019:  ldfld      int32 XYZ.Expr::item
+    IL_001e:  stloc.s    V_5
+    IL_0020:  ldloc.3
+    IL_0021:  ldfld      int32 XYZ.Expr::item
+    IL_0026:  stloc.s    V_6
+    IL_0028:  ldloc.s    V_4
+    IL_002a:  stloc.s    V_7
+    IL_002c:  ldloc.s    V_5
+    IL_002e:  ldloc.s    V_6
+    IL_0030:  ceq
+    IL_0032:  ret
+
+    IL_0033:  ldc.i4.0
+    IL_0034:  ret
+
+    IL_0035:  ldarg.1
+    IL_0036:  ldnull
+    IL_0037:  cgt.un
+    IL_0039:  ldc.i4.0
+    IL_003a:  ceq
+    IL_003c:  ret
+  } 
+
+  .method public hidebysig virtual final instance bool  Equals(class XYZ.Expr obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_001d
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_001b
+
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  stloc.0
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  ldloc.0
+    IL_000d:  ldfld      int32 XYZ.Expr::item
+    IL_0012:  ldloc.1
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  ceq
+    IL_001a:  ret
+
+    IL_001b:  ldc.i4.0
+    IL_001c:  ret
+
+    IL_001d:  ldarg.1
+    IL_001e:  ldnull
+    IL_001f:  cgt.un
+    IL_0021:  ldc.i4.0
+    IL_0022:  ceq
+    IL_0024:  ret
+  } 
+
+  .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  isinst     XYZ.Expr
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_0012
+
+    IL_000a:  ldarg.0
+    IL_000b:  ldloc.0
+    IL_000c:  callvirt   instance bool XYZ.Expr::Equals(class XYZ.Expr)
+    IL_0011:  ret
+
+    IL_0012:  ldc.i4.0
+    IL_0013:  ret
+  } 
+
+  .property instance int32 Tag()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .get instance int32 XYZ.Expr::get_Tag()
+  } 
+  .property instance int32 Item()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32,
+                                                                                                int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance int32 XYZ.Expr::get_Item()
+  } 
+} 
+
+.class public auto ansi serializable beforefieldinit XYZ.MyExn
+       extends [runtime]System.Exception
+       implements [runtime]System.Collections.IStructuralEquatable
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+  .field assembly int32 Data0@
+  .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      int32 XYZ.MyExn::Data0@
+    IL_000d:  ret
+  } 
+
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+    IL_0006:  ret
+  } 
+
+  .method family specialname rtspecialname 
+          instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                               valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  ldarg.2
+    IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                               valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+    IL_0008:  ret
+  } 
+
+  .method public hidebysig specialname instance int32 get_Data0() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      int32 XYZ.MyExn::Data0@
+    IL_0006:  ret
+  } 
+
+  .method public strict virtual instance string get_Message() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.MyExn>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.MyExn,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             class [runtime]System.Collections.IEqualityComparer V_1,
+             int32 V_2,
+             class [runtime]System.Collections.IEqualityComparer V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0027
+
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.0
+    IL_0005:  ldc.i4     0x9e3779b9
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  ldarg.0
+    IL_000d:  castclass  XYZ.MyExn
+    IL_0012:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0017:  stloc.2
+    IL_0018:  ldloc.1
+    IL_0019:  stloc.3
+    IL_001a:  ldloc.2
+    IL_001b:  ldloc.0
+    IL_001c:  ldc.i4.6
+    IL_001d:  shl
+    IL_001e:  ldloc.0
+    IL_001f:  ldc.i4.2
+    IL_0020:  shr
+    IL_0021:  add
+    IL_0022:  add
+    IL_0023:  add
+    IL_0024:  stloc.0
+    IL_0025:  ldloc.0
+    IL_0026:  ret
+
+    IL_0027:  ldc.i4.0
+    IL_0028:  ret
+  } 
+
+  .method public hidebysig virtual instance int32 GetHashCode() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0006:  callvirt   instance int32 XYZ.MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+    IL_000b:  ret
+  } 
+
+  .method public hidebysig virtual instance bool 
+          Equals(object obj,
+                 class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0,
+             class [runtime]System.Exception V_1,
+             object V_2,
+             class [runtime]System.Collections.IEqualityComparer V_3,
+             int32 V_4,
+             int32 V_5,
+             class [runtime]System.Collections.IEqualityComparer V_6)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0046
+
+    IL_0003:  ldarg.1
+    IL_0004:  isinst     [runtime]System.Exception
+    IL_0009:  stloc.0
+    IL_000a:  ldloc.0
+    IL_000b:  brfalse.s  IL_0044
+
+    IL_000d:  ldloc.0
+    IL_000e:  stloc.1
+    IL_000f:  ldloc.0
+    IL_0010:  stloc.2
+    IL_0011:  ldloc.2
+    IL_0012:  isinst     XYZ.MyExn
+    IL_0017:  ldnull
+    IL_0018:  cgt.un
+    IL_001a:  brfalse.s  IL_0042
+
+    IL_001c:  ldarg.2
+    IL_001d:  stloc.3
+    IL_001e:  ldarg.0
+    IL_001f:  castclass  XYZ.MyExn
+    IL_0024:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0029:  stloc.s    V_4
+    IL_002b:  ldloc.1
+    IL_002c:  castclass  XYZ.MyExn
+    IL_0031:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0036:  stloc.s    V_5
+    IL_0038:  ldloc.3
+    IL_0039:  stloc.s    V_6
+    IL_003b:  ldloc.s    V_4
+    IL_003d:  ldloc.s    V_5
+    IL_003f:  ceq
+    IL_0041:  ret
+
+    IL_0042:  ldc.i4.0
+    IL_0043:  ret
+
+    IL_0044:  ldc.i4.0
+    IL_0045:  ret
+
+    IL_0046:  ldarg.1
+    IL_0047:  ldnull
+    IL_0048:  cgt.un
+    IL_004a:  ldc.i4.0
+    IL_004b:  ceq
+    IL_004d:  ret
+  } 
+
+  .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (object V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0030
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_002e
+
+    IL_0006:  ldarg.1
+    IL_0007:  stloc.0
+    IL_0008:  ldloc.0
+    IL_0009:  isinst     XYZ.MyExn
+    IL_000e:  ldnull
+    IL_000f:  cgt.un
+    IL_0011:  brfalse.s  IL_002c
+
+    IL_0013:  ldarg.0
+    IL_0014:  castclass  XYZ.MyExn
+    IL_0019:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_001e:  ldarg.1
+    IL_001f:  castclass  XYZ.MyExn
+    IL_0024:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0029:  ceq
+    IL_002b:  ret
+
+    IL_002c:  ldc.i4.0
+    IL_002d:  ret
+
+    IL_002e:  ldc.i4.0
+    IL_002f:  ret
+
+    IL_0030:  ldarg.1
+    IL_0031:  ldnull
+    IL_0032:  cgt.un
+    IL_0034:  ldc.i4.0
+    IL_0035:  ceq
+    IL_0037:  ret
+  } 
+
+  .method public hidebysig virtual instance bool Equals(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  isinst     [runtime]System.Exception
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_0012
+
+    IL_000a:  ldarg.0
+    IL_000b:  ldloc.0
+    IL_000c:  callvirt   instance bool XYZ.MyExn::Equals(class [runtime]System.Exception)
+    IL_0011:  ret
+
+    IL_0012:  ldc.i4.0
+    IL_0013:  ret
+  } 
+
+  .property instance int32 Data0()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+    .get instance int32 XYZ.MyExn::get_Data0()
+  } 
+} 
+
+.class public auto ansi serializable XYZ.A
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .field assembly string x
+  .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  ldarg.1
+    IL_000a:  stfld      string XYZ.A::x
+    IL_000f:  ret
+  } 
+
+  .method public hidebysig specialname instance string get_X() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      string XYZ.A::x
+    IL_0006:  ret
+  } 
+
+  .property instance string X()
+  {
+    .get instance string XYZ.A::get_X()
+  } 
+} 
+
+.class public abstract auto ansi sealed XYZ.ABC
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Expr
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class XYZ.ABC/Expr>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class XYZ.ABC/Expr>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                         61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field assembly initonly int32 item
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public static class XYZ.ABC/Expr NewNum(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void XYZ.ABC/Expr::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+    {
+      .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                              class [runtime]System.Type) = ( 01 00 60 06 00 00 0C 58 59 5A 2E 41 42 43 2B 45   
+                                                                                                                                                     78 70 72 00 00 )                                  
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 XYZ.ABC/Expr::item
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Item() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/Expr>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class XYZ.ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4,
+               class [runtime]System.Collections.IComparer V_5,
+               int32 V_6,
+               int32 V_7)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_003b
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_0039
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.0
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.1
+      IL_001a:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.2
+      IL_0022:  stloc.s    V_5
+      IL_0024:  ldloc.3
+      IL_0025:  stloc.s    V_6
+      IL_0027:  ldloc.s    V_4
+      IL_0029:  stloc.s    V_7
+      IL_002b:  ldloc.s    V_6
+      IL_002d:  ldloc.s    V_7
+      IL_002f:  cgt
+      IL_0031:  ldloc.s    V_6
+      IL_0033:  ldloc.s    V_7
+      IL_0035:  clt
+      IL_0037:  sub
+      IL_0038:  ret
+
+      IL_0039:  ldc.i4.1
+      IL_003a:  ret
+
+      IL_003b:  ldarg.1
+      IL_003c:  brfalse.s  IL_0040
+
+      IL_003e:  ldc.i4.m1
+      IL_003f:  ret
+
+      IL_0040:  ldc.i4.0
+      IL_0041:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  XYZ.ABC/Expr
+      IL_0007:  callvirt   instance int32 XYZ.ABC/Expr::CompareTo(class XYZ.ABC/Expr)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class XYZ.ABC/Expr V_2,
+               class [runtime]System.Collections.IComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IComparer V_6,
+               int32 V_7,
+               int32 V_8)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  XYZ.ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_0045
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  XYZ.ABC/Expr
+      IL_0010:  brfalse.s  IL_0043
+
+      IL_0012:  ldarg.0
+      IL_0013:  pop
+      IL_0014:  ldarg.0
+      IL_0015:  stloc.1
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  ldarg.2
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.1
+      IL_001b:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0020:  stloc.s    V_4
+      IL_0022:  ldloc.2
+      IL_0023:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0028:  stloc.s    V_5
+      IL_002a:  ldloc.3
+      IL_002b:  stloc.s    V_6
+      IL_002d:  ldloc.s    V_4
+      IL_002f:  stloc.s    V_7
+      IL_0031:  ldloc.s    V_5
+      IL_0033:  stloc.s    V_8
+      IL_0035:  ldloc.s    V_7
+      IL_0037:  ldloc.s    V_8
+      IL_0039:  cgt
+      IL_003b:  ldloc.s    V_7
+      IL_003d:  ldloc.s    V_8
+      IL_003f:  clt
+      IL_0041:  sub
+      IL_0042:  ret
+
+      IL_0043:  ldc.i4.1
+      IL_0044:  ret
+
+      IL_0045:  ldarg.1
+      IL_0046:  unbox.any  XYZ.ABC/Expr
+      IL_004b:  brfalse.s  IL_004f
+
+      IL_004d:  ldc.i4.m1
+      IL_004e:  ret
+
+      IL_004f:  ldc.i4.0
+      IL_0050:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class XYZ.ABC/Expr V_1,
+               class [runtime]System.Collections.IEqualityComparer V_2,
+               int32 V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0029
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldarg.0
+      IL_0008:  stloc.1
+      IL_0009:  ldc.i4.0
+      IL_000a:  stloc.0
+      IL_000b:  ldc.i4     0x9e3779b9
+      IL_0010:  ldarg.1
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.2
+      IL_001a:  stloc.s    V_4
+      IL_001c:  ldloc.3
+      IL_001d:  ldloc.0
+      IL_001e:  ldc.i4.6
+      IL_001f:  shl
+      IL_0020:  ldloc.0
+      IL_0021:  ldc.i4.2
+      IL_0022:  shr
+      IL_0023:  add
+      IL_0024:  add
+      IL_0025:  add
+      IL_0026:  stloc.0
+      IL_0027:  ldloc.0
+      IL_0028:  ret
+
+      IL_0029:  ldc.i4.0
+      IL_002a:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 XYZ.ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class XYZ.ABC/Expr V_2,
+               class XYZ.ABC/Expr V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4,
+               int32 V_5,
+               int32 V_6,
+               class [runtime]System.Collections.IEqualityComparer V_7)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0035
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     XYZ.ABC/Expr
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0033
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  pop
+      IL_0011:  ldarg.0
+      IL_0012:  stloc.2
+      IL_0013:  ldloc.1
+      IL_0014:  stloc.3
+      IL_0015:  ldarg.2
+      IL_0016:  stloc.s    V_4
+      IL_0018:  ldloc.2
+      IL_0019:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_001e:  stloc.s    V_5
+      IL_0020:  ldloc.3
+      IL_0021:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0026:  stloc.s    V_6
+      IL_0028:  ldloc.s    V_4
+      IL_002a:  stloc.s    V_7
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  ldloc.s    V_6
+      IL_0030:  ceq
+      IL_0032:  ret
+
+      IL_0033:  ldc.i4.0
+      IL_0034:  ret
+
+      IL_0035:  ldarg.1
+      IL_0036:  ldnull
+      IL_0037:  cgt.un
+      IL_0039:  ldc.i4.0
+      IL_003a:  ceq
+      IL_003c:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class XYZ.ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001d
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001b
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldloc.0
+      IL_000d:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  ceq
+      IL_001a:  ret
+
+      IL_001b:  ldc.i4.0
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  ldnull
+      IL_001f:  cgt.un
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     XYZ.ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool XYZ.ABC/Expr::Equals(class XYZ.ABC/Expr)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 XYZ.ABC/Expr::get_Tag()
+    } 
+    .property instance int32 Item()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .get instance int32 XYZ.ABC/Expr::get_Item()
+    } 
+  } 
+
+  .class auto ansi serializable nested public beforefieldinit MyExn
+         extends [runtime]System.Exception
+         implements [runtime]System.Collections.IStructuralEquatable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+    .field assembly int32 Data0@
+    .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 XYZ.ABC/MyExn::Data0@
+      IL_000d:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method family specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  ldarg.2
+      IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_Data0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 XYZ.ABC/MyExn::Data0@
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string get_Message() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/MyExn>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/MyExn,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1,
+               int32 V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0027
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldc.i4     0x9e3779b9
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  castclass  XYZ.ABC/MyExn
+      IL_0012:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0017:  stloc.2
+      IL_0018:  ldloc.1
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.2
+      IL_001b:  ldloc.0
+      IL_001c:  ldc.i4.6
+      IL_001d:  shl
+      IL_001e:  ldloc.0
+      IL_001f:  ldc.i4.2
+      IL_0020:  shr
+      IL_0021:  add
+      IL_0022:  add
+      IL_0023:  add
+      IL_0024:  stloc.0
+      IL_0025:  ldloc.0
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 XYZ.ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual instance bool 
+            Equals(object obj,
+                   class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1,
+               object V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IEqualityComparer V_6)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0046
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     [runtime]System.Exception
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0044
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldloc.0
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.2
+      IL_0012:  isinst     XYZ.ABC/MyExn
+      IL_0017:  ldnull
+      IL_0018:  cgt.un
+      IL_001a:  brfalse.s  IL_0042
+
+      IL_001c:  ldarg.2
+      IL_001d:  stloc.3
+      IL_001e:  ldarg.0
+      IL_001f:  castclass  XYZ.ABC/MyExn
+      IL_0024:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0029:  stloc.s    V_4
+      IL_002b:  ldloc.1
+      IL_002c:  castclass  XYZ.ABC/MyExn
+      IL_0031:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0036:  stloc.s    V_5
+      IL_0038:  ldloc.3
+      IL_0039:  stloc.s    V_6
+      IL_003b:  ldloc.s    V_4
+      IL_003d:  ldloc.s    V_5
+      IL_003f:  ceq
+      IL_0041:  ret
+
+      IL_0042:  ldc.i4.0
+      IL_0043:  ret
+
+      IL_0044:  ldc.i4.0
+      IL_0045:  ret
+
+      IL_0046:  ldarg.1
+      IL_0047:  ldnull
+      IL_0048:  cgt.un
+      IL_004a:  ldc.i4.0
+      IL_004b:  ceq
+      IL_004d:  ret
+    } 
+
+    .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0030
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002e
+
+      IL_0006:  ldarg.1
+      IL_0007:  stloc.0
+      IL_0008:  ldloc.0
+      IL_0009:  isinst     XYZ.ABC/MyExn
+      IL_000e:  ldnull
+      IL_000f:  cgt.un
+      IL_0011:  brfalse.s  IL_002c
+
+      IL_0013:  ldarg.0
+      IL_0014:  castclass  XYZ.ABC/MyExn
+      IL_0019:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_001e:  ldarg.1
+      IL_001f:  castclass  XYZ.ABC/MyExn
+      IL_0024:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0029:  ceq
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+
+      IL_0030:  ldarg.1
+      IL_0031:  ldnull
+      IL_0032:  cgt.un
+      IL_0034:  ldc.i4.0
+      IL_0035:  ceq
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual instance bool Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     [runtime]System.Exception
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool XYZ.ABC/MyExn::Equals(class [runtime]System.Exception)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Data0()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance int32 XYZ.ABC/MyExn::get_Data0()
+    } 
+  } 
+
+  .class auto ansi serializable nested public A
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly string x
+    .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldarg.1
+      IL_000a:  stfld      string XYZ.ABC/A::x
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance string  get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string XYZ.ABC/A::x
+      IL_0006:  ret
+    } 
+
+    .property instance string X()
+    {
+      .get instance string XYZ.ABC/A::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public ABC
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested public beforefieldinit Expr
+           extends [runtime]System.Object
+           implements class [runtime]System.IEquatable`1<class XYZ.ABC/ABC/Expr>,
+                      [runtime]System.Collections.IStructuralEquatable,
+                      class [runtime]System.IComparable`1<class XYZ.ABC/ABC/Expr>,
+                      [runtime]System.IComparable,
+                      [runtime]System.Collections.IStructuralComparable
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                           61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public static class XYZ.ABC/ABC/Expr NewNum(int32 item) cil managed
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void XYZ.ABC/ABC/Expr::.ctor(int32)
+        IL_0006:  ret
+      } 
+
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 10 58 59 5A 2E 41 42 43 2B 41   
+                                                                                                                                                       42 43 2B 45 78 70 72 00 00 )                      
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Tag() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  pop
+        IL_0002:  ldc.i4.0
+        IL_0003:  ret
+      } 
+
+      .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+0.8A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public strict virtual instance string ToString() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/ABC/Expr>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(class XYZ.ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IComparer V_2,
+                 int32 V_3,
+                 int32 V_4,
+                 class [runtime]System.Collections.IComparer V_5,
+                 int32 V_6,
+                 int32 V_7)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_003b
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_0039
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.0
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.1
+        IL_001a:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_001f:  stloc.s    V_4
+        IL_0021:  ldloc.2
+        IL_0022:  stloc.s    V_5
+        IL_0024:  ldloc.3
+        IL_0025:  stloc.s    V_6
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  stloc.s    V_7
+        IL_002b:  ldloc.s    V_6
+        IL_002d:  ldloc.s    V_7
+        IL_002f:  cgt
+        IL_0031:  ldloc.s    V_6
+        IL_0033:  ldloc.s    V_7
+        IL_0035:  clt
+        IL_0037:  sub
+        IL_0038:  ret
+
+        IL_0039:  ldc.i4.1
+        IL_003a:  ret
+
+        IL_003b:  ldarg.1
+        IL_003c:  brfalse.s  IL_0040
+
+        IL_003e:  ldc.i4.m1
+        IL_003f:  ret
+
+        IL_0040:  ldc.i4.0
+        IL_0041:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0007:  callvirt   instance int32 XYZ.ABC/ABC/Expr::CompareTo(class XYZ.ABC/ABC/Expr)
+        IL_000c:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance int32  CompareTo(object obj,
+                                        class [runtime]System.Collections.IComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class XYZ.ABC/ABC/Expr V_2,
+                 class [runtime]System.Collections.IComparer V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class [runtime]System.Collections.IComparer V_6,
+                 int32 V_7,
+                 int32 V_8)
+        IL_0000:  ldarg.1
+        IL_0001:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  brfalse.s  IL_0045
+
+        IL_000a:  ldarg.1
+        IL_000b:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0010:  brfalse.s  IL_0043
+
+        IL_0012:  ldarg.0
+        IL_0013:  pop
+        IL_0014:  ldarg.0
+        IL_0015:  stloc.1
+        IL_0016:  ldloc.0
+        IL_0017:  stloc.2
+        IL_0018:  ldarg.2
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.1
+        IL_001b:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0020:  stloc.s    V_4
+        IL_0022:  ldloc.2
+        IL_0023:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0028:  stloc.s    V_5
+        IL_002a:  ldloc.3
+        IL_002b:  stloc.s    V_6
+        IL_002d:  ldloc.s    V_4
+        IL_002f:  stloc.s    V_7
+        IL_0031:  ldloc.s    V_5
+        IL_0033:  stloc.s    V_8
+        IL_0035:  ldloc.s    V_7
+        IL_0037:  ldloc.s    V_8
+        IL_0039:  cgt
+        IL_003b:  ldloc.s    V_7
+        IL_003d:  ldloc.s    V_8
+        IL_003f:  clt
+        IL_0041:  sub
+        IL_0042:  ret
+
+        IL_0043:  ldc.i4.1
+        IL_0044:  ret
+
+        IL_0045:  ldarg.1
+        IL_0046:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_004b:  brfalse.s  IL_004f
+
+        IL_004d:  ldc.i4.m1
+        IL_004e:  ret
+
+        IL_004f:  ldc.i4.0
+        IL_0050:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IEqualityComparer V_2,
+                 int32 V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0029
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldarg.0
+        IL_0006:  pop
+        IL_0007:  ldarg.0
+        IL_0008:  stloc.1
+        IL_0009:  ldc.i4.0
+        IL_000a:  stloc.0
+        IL_000b:  ldc.i4     0x9e3779b9
+        IL_0010:  ldarg.1
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.2
+        IL_001a:  stloc.s    V_4
+        IL_001c:  ldloc.3
+        IL_001d:  ldloc.0
+        IL_001e:  ldc.i4.6
+        IL_001f:  shl
+        IL_0020:  ldloc.0
+        IL_0021:  ldc.i4.2
+        IL_0022:  shr
+        IL_0023:  add
+        IL_0024:  add
+        IL_0025:  add
+        IL_0026:  stloc.0
+        IL_0027:  ldloc.0
+        IL_0028:  ret
+
+        IL_0029:  ldc.i4.0
+        IL_002a:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 XYZ.ABC/ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance bool  Equals(object obj,
+                                    class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class XYZ.ABC/ABC/Expr V_2,
+                 class XYZ.ABC/ABC/Expr V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4,
+                 int32 V_5,
+                 int32 V_6,
+                 class [runtime]System.Collections.IEqualityComparer V_7)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0035
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     XYZ.ABC/ABC/Expr
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0033
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldarg.0
+        IL_0010:  pop
+        IL_0011:  ldarg.0
+        IL_0012:  stloc.2
+        IL_0013:  ldloc.1
+        IL_0014:  stloc.3
+        IL_0015:  ldarg.2
+        IL_0016:  stloc.s    V_4
+        IL_0018:  ldloc.2
+        IL_0019:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_001e:  stloc.s    V_5
+        IL_0020:  ldloc.3
+        IL_0021:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0026:  stloc.s    V_6
+        IL_0028:  ldloc.s    V_4
+        IL_002a:  stloc.s    V_7
+        IL_002c:  ldloc.s    V_5
+        IL_002e:  ldloc.s    V_6
+        IL_0030:  ceq
+        IL_0032:  ret
+
+        IL_0033:  ldc.i4.0
+        IL_0034:  ret
+
+        IL_0035:  ldarg.1
+        IL_0036:  ldnull
+        IL_0037:  cgt.un
+        IL_0039:  ldc.i4.0
+        IL_003a:  ceq
+        IL_003c:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(class XYZ.ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_001d
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_001b
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldloc.0
+        IL_000d:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  ceq
+        IL_001a:  ret
+
+        IL_001b:  ldc.i4.0
+        IL_001c:  ret
+
+        IL_001d:  ldarg.1
+        IL_001e:  ldnull
+        IL_001f:  cgt.un
+        IL_0021:  ldc.i4.0
+        IL_0022:  ceq
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     XYZ.ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool XYZ.ABC/ABC/Expr::Equals(class XYZ.ABC/ABC/Expr)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Tag()
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/Expr::get_Tag()
+      } 
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/Expr::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit MyExn
+           extends [runtime]System.Exception
+           implements [runtime]System.Collections.IStructuralEquatable
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+      .field assembly int32 Data0@
+      .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 XYZ.ABC/ABC/MyExn::Data0@
+        IL_000d:  ret
+      } 
+
+      .method public specialname rtspecialname instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method family specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  ldarg.2
+        IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+        IL_0008:  ret
+      } 
+
+      .method public hidebysig specialname instance int32  get_Data0() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 XYZ.ABC/ABC/MyExn::Data0@
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance string get_Message() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/ABC/MyExn>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/MyExn,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [runtime]System.Collections.IEqualityComparer V_1,
+                 int32 V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0027
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldc.i4     0x9e3779b9
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldarg.0
+        IL_000d:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0012:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0017:  stloc.2
+        IL_0018:  ldloc.1
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.2
+        IL_001b:  ldloc.0
+        IL_001c:  ldc.i4.6
+        IL_001d:  shl
+        IL_001e:  ldloc.0
+        IL_001f:  ldc.i4.2
+        IL_0020:  shr
+        IL_0021:  add
+        IL_0022:  add
+        IL_0023:  add
+        IL_0024:  stloc.0
+        IL_0025:  ldloc.0
+        IL_0026:  ret
+
+        IL_0027:  ldc.i4.0
+        IL_0028:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 XYZ.ABC/ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual instance bool 
+              Equals(object obj,
+                     class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1,
+                 object V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class [runtime]System.Collections.IEqualityComparer V_6)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0046
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     [runtime]System.Exception
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0044
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldloc.0
+        IL_0010:  stloc.2
+        IL_0011:  ldloc.2
+        IL_0012:  isinst     XYZ.ABC/ABC/MyExn
+        IL_0017:  ldnull
+        IL_0018:  cgt.un
+        IL_001a:  brfalse.s  IL_0042
+
+        IL_001c:  ldarg.2
+        IL_001d:  stloc.3
+        IL_001e:  ldarg.0
+        IL_001f:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0024:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0029:  stloc.s    V_4
+        IL_002b:  ldloc.1
+        IL_002c:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0031:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0036:  stloc.s    V_5
+        IL_0038:  ldloc.3
+        IL_0039:  stloc.s    V_6
+        IL_003b:  ldloc.s    V_4
+        IL_003d:  ldloc.s    V_5
+        IL_003f:  ceq
+        IL_0041:  ret
+
+        IL_0042:  ldc.i4.0
+        IL_0043:  ret
+
+        IL_0044:  ldc.i4.0
+        IL_0045:  ret
+
+        IL_0046:  ldarg.1
+        IL_0047:  ldnull
+        IL_0048:  cgt.un
+        IL_004a:  ldc.i4.0
+        IL_004b:  ceq
+        IL_004d:  ret
+      } 
+
+      .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (object V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0030
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002e
+
+        IL_0006:  ldarg.1
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  isinst     XYZ.ABC/ABC/MyExn
+        IL_000e:  ldnull
+        IL_000f:  cgt.un
+        IL_0011:  brfalse.s  IL_002c
+
+        IL_0013:  ldarg.0
+        IL_0014:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0019:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_001e:  ldarg.1
+        IL_001f:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0024:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ceq
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+
+        IL_0030:  ldarg.1
+        IL_0031:  ldnull
+        IL_0032:  cgt.un
+        IL_0034:  ldc.i4.0
+        IL_0035:  ceq
+        IL_0037:  ret
+      } 
+
+      .method public hidebysig virtual instance bool Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     [runtime]System.Exception
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool XYZ.ABC/ABC/MyExn::Equals(class [runtime]System.Exception)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Data0()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+      } 
+    } 
+
+    .class auto ansi serializable nested public A
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+      .field assembly string x
+      .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  ldarg.1
+        IL_000a:  stfld      string XYZ.ABC/ABC/A::x
+        IL_000f:  ret
+      } 
+
+      .method public hidebysig specialname instance string  get_X() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      string XYZ.ABC/ABC/A::x
+        IL_0006:  ret
+      } 
+
+      .property instance string X()
+      {
+        .get instance string XYZ.ABC/ABC/A::get_X()
+      } 
+    } 
+
+    .method public static int32  'add'(int32 x,
+                                       int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public specialname static string get_greeting() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  ret
+    } 
+
+    .property string greeting()
+    {
+      .get string XYZ.ABC/ABC::get_greeting()
+    } 
+  } 
+
+  .method public static int32  'add'(int32 x,
+                                     int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public specialname static string get_greeting() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello"
+    IL_0005:  ret
+  } 
+
+  .property string greeting()
+  {
+    .get string XYZ.ABC::get_greeting()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOn.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOn.il.netcore.release.bsl
new file mode 100644
index 00000000000..2d15f5a89d6
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace.fs.RealInternalSignatureOn.il.netcore.release.bsl
@@ -0,0 +1,2115 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public auto autochar serializable sealed beforefieldinit XYZ.Expr
+       extends [runtime]System.Object
+       implements class [runtime]System.IEquatable`1<class XYZ.Expr>,
+                  [runtime]System.Collections.IStructuralEquatable,
+                  class [runtime]System.IComparable`1<class XYZ.Expr>,
+                  [runtime]System.IComparable,
+                  [runtime]System.Collections.IStructuralComparable
+{
+  .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                       61 79 28 29 2C 6E 71 7D 00 00 )                   
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+  .field assembly initonly int32 item
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static class XYZ.Expr  NewNum(int32 item) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  newobj     instance void XYZ.Expr::.ctor(int32)
+    IL_0006:  ret
+  } 
+
+  .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+  {
+    .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                            class [runtime]System.Type) = ( 01 00 60 06 00 00 08 58 59 5A 2E 45 78 70 72 00   
+                                                                                                                                                   00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      int32 XYZ.Expr::item
+    IL_000d:  ret
+  } 
+
+  .method public hidebysig instance int32 get_Item() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      int32 XYZ.Expr::item
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig instance int32 get_Tag() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  pop
+    IL_0002:  ldc.i4.0
+    IL_0003:  ret
+  } 
+
+  .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+0.8A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public strict virtual instance string ToString() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.Expr>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  CompareTo(class XYZ.Expr obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class [runtime]System.Collections.IComparer V_2,
+             int32 V_3,
+             int32 V_4)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_002f
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_002d
+
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  stloc.0
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.0
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.1
+    IL_001a:  ldfld      int32 XYZ.Expr::item
+    IL_001f:  stloc.s    V_4
+    IL_0021:  ldloc.3
+    IL_0022:  ldloc.s    V_4
+    IL_0024:  cgt
+    IL_0026:  ldloc.3
+    IL_0027:  ldloc.s    V_4
+    IL_0029:  clt
+    IL_002b:  sub
+    IL_002c:  ret
+
+    IL_002d:  ldc.i4.1
+    IL_002e:  ret
+
+    IL_002f:  ldarg.1
+    IL_0030:  brfalse.s  IL_0034
+
+    IL_0032:  ldc.i4.m1
+    IL_0033:  ret
+
+    IL_0034:  ldc.i4.0
+    IL_0035:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  unbox.any  XYZ.Expr
+    IL_0007:  callvirt   instance int32 XYZ.Expr::CompareTo(class XYZ.Expr)
+    IL_000c:  ret
+  } 
+
+  .method public hidebysig virtual final 
+          instance int32  CompareTo(object obj,
+                                    class [runtime]System.Collections.IComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class XYZ.Expr V_2,
+             class [runtime]System.Collections.IComparer V_3,
+             int32 V_4,
+             int32 V_5)
+    IL_0000:  ldarg.1
+    IL_0001:  unbox.any  XYZ.Expr
+    IL_0006:  stloc.0
+    IL_0007:  ldarg.0
+    IL_0008:  brfalse.s  IL_003a
+
+    IL_000a:  ldarg.1
+    IL_000b:  unbox.any  XYZ.Expr
+    IL_0010:  brfalse.s  IL_0038
+
+    IL_0012:  ldarg.0
+    IL_0013:  pop
+    IL_0014:  ldarg.0
+    IL_0015:  stloc.1
+    IL_0016:  ldloc.0
+    IL_0017:  stloc.2
+    IL_0018:  ldarg.2
+    IL_0019:  stloc.3
+    IL_001a:  ldloc.1
+    IL_001b:  ldfld      int32 XYZ.Expr::item
+    IL_0020:  stloc.s    V_4
+    IL_0022:  ldloc.2
+    IL_0023:  ldfld      int32 XYZ.Expr::item
+    IL_0028:  stloc.s    V_5
+    IL_002a:  ldloc.s    V_4
+    IL_002c:  ldloc.s    V_5
+    IL_002e:  cgt
+    IL_0030:  ldloc.s    V_4
+    IL_0032:  ldloc.s    V_5
+    IL_0034:  clt
+    IL_0036:  sub
+    IL_0037:  ret
+
+    IL_0038:  ldc.i4.1
+    IL_0039:  ret
+
+    IL_003a:  ldarg.1
+    IL_003b:  unbox.any  XYZ.Expr
+    IL_0040:  brfalse.s  IL_0044
+
+    IL_0042:  ldc.i4.m1
+    IL_0043:  ret
+
+    IL_0044:  ldc.i4.0
+    IL_0045:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             class XYZ.Expr V_1,
+             class [runtime]System.Collections.IEqualityComparer V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0024
+
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.0
+    IL_0005:  ldarg.0
+    IL_0006:  pop
+    IL_0007:  ldarg.0
+    IL_0008:  stloc.1
+    IL_0009:  ldc.i4.0
+    IL_000a:  stloc.0
+    IL_000b:  ldc.i4     0x9e3779b9
+    IL_0010:  ldarg.1
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.1
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  ldloc.0
+    IL_0019:  ldc.i4.6
+    IL_001a:  shl
+    IL_001b:  ldloc.0
+    IL_001c:  ldc.i4.2
+    IL_001d:  shr
+    IL_001e:  add
+    IL_001f:  add
+    IL_0020:  add
+    IL_0021:  stloc.0
+    IL_0022:  ldloc.0
+    IL_0023:  ret
+
+    IL_0024:  ldc.i4.0
+    IL_0025:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0006:  callvirt   instance int32 XYZ.Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+    IL_000b:  ret
+  } 
+
+  .method public hidebysig virtual final 
+          instance bool  Equals(object obj,
+                                class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class XYZ.Expr V_2,
+             class XYZ.Expr V_3,
+             class [runtime]System.Collections.IEqualityComparer V_4)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0029
+
+    IL_0003:  ldarg.1
+    IL_0004:  isinst     XYZ.Expr
+    IL_0009:  stloc.0
+    IL_000a:  ldloc.0
+    IL_000b:  brfalse.s  IL_0027
+
+    IL_000d:  ldloc.0
+    IL_000e:  stloc.1
+    IL_000f:  ldarg.0
+    IL_0010:  pop
+    IL_0011:  ldarg.0
+    IL_0012:  stloc.2
+    IL_0013:  ldloc.1
+    IL_0014:  stloc.3
+    IL_0015:  ldarg.2
+    IL_0016:  stloc.s    V_4
+    IL_0018:  ldloc.2
+    IL_0019:  ldfld      int32 XYZ.Expr::item
+    IL_001e:  ldloc.3
+    IL_001f:  ldfld      int32 XYZ.Expr::item
+    IL_0024:  ceq
+    IL_0026:  ret
+
+    IL_0027:  ldc.i4.0
+    IL_0028:  ret
+
+    IL_0029:  ldarg.1
+    IL_002a:  ldnull
+    IL_002b:  cgt.un
+    IL_002d:  ldc.i4.0
+    IL_002e:  ceq
+    IL_0030:  ret
+  } 
+
+  .method public hidebysig virtual final instance bool  Equals(class XYZ.Expr obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_001d
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_001b
+
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  stloc.0
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  ldloc.0
+    IL_000d:  ldfld      int32 XYZ.Expr::item
+    IL_0012:  ldloc.1
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  ceq
+    IL_001a:  ret
+
+    IL_001b:  ldc.i4.0
+    IL_001c:  ret
+
+    IL_001d:  ldarg.1
+    IL_001e:  ldnull
+    IL_001f:  cgt.un
+    IL_0021:  ldc.i4.0
+    IL_0022:  ceq
+    IL_0024:  ret
+  } 
+
+  .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  isinst     XYZ.Expr
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_0012
+
+    IL_000a:  ldarg.0
+    IL_000b:  ldloc.0
+    IL_000c:  callvirt   instance bool XYZ.Expr::Equals(class XYZ.Expr)
+    IL_0011:  ret
+
+    IL_0012:  ldc.i4.0
+    IL_0013:  ret
+  } 
+
+  .property instance int32 Tag()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .get instance int32 XYZ.Expr::get_Tag()
+  } 
+  .property instance int32 Item()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32,
+                                                                                                int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance int32 XYZ.Expr::get_Item()
+  } 
+} 
+
+.class public auto ansi serializable beforefieldinit XYZ.MyExn
+       extends [runtime]System.Exception
+       implements [runtime]System.Collections.IStructuralEquatable
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+  .field assembly int32 Data0@
+  .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      int32 XYZ.MyExn::Data0@
+    IL_000d:  ret
+  } 
+
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+    IL_0006:  ret
+  } 
+
+  .method family specialname rtspecialname 
+          instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                               valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  ldarg.2
+    IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                               valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+    IL_0008:  ret
+  } 
+
+  .method public hidebysig specialname instance int32 get_Data0() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      int32 XYZ.MyExn::Data0@
+    IL_0006:  ret
+  } 
+
+  .method public strict virtual instance string get_Message() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.MyExn>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.MyExn,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             class [runtime]System.Collections.IEqualityComparer V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0023
+
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.0
+    IL_0005:  ldc.i4     0x9e3779b9
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  ldarg.0
+    IL_000d:  castclass  XYZ.MyExn
+    IL_0012:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0017:  ldloc.0
+    IL_0018:  ldc.i4.6
+    IL_0019:  shl
+    IL_001a:  ldloc.0
+    IL_001b:  ldc.i4.2
+    IL_001c:  shr
+    IL_001d:  add
+    IL_001e:  add
+    IL_001f:  add
+    IL_0020:  stloc.0
+    IL_0021:  ldloc.0
+    IL_0022:  ret
+
+    IL_0023:  ldc.i4.0
+    IL_0024:  ret
+  } 
+
+  .method public hidebysig virtual instance int32 GetHashCode() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0006:  callvirt   instance int32 XYZ.MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+    IL_000b:  ret
+  } 
+
+  .method public hidebysig virtual instance bool 
+          Equals(object obj,
+                 class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0,
+             class [runtime]System.Exception V_1,
+             object V_2,
+             class [runtime]System.Collections.IEqualityComparer V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_003b
+
+    IL_0003:  ldarg.1
+    IL_0004:  isinst     [runtime]System.Exception
+    IL_0009:  stloc.0
+    IL_000a:  ldloc.0
+    IL_000b:  brfalse.s  IL_0039
+
+    IL_000d:  ldloc.0
+    IL_000e:  stloc.1
+    IL_000f:  ldloc.0
+    IL_0010:  stloc.2
+    IL_0011:  ldloc.2
+    IL_0012:  isinst     XYZ.MyExn
+    IL_0017:  ldnull
+    IL_0018:  cgt.un
+    IL_001a:  brfalse.s  IL_0037
+
+    IL_001c:  ldarg.2
+    IL_001d:  stloc.3
+    IL_001e:  ldarg.0
+    IL_001f:  castclass  XYZ.MyExn
+    IL_0024:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0029:  ldloc.1
+    IL_002a:  castclass  XYZ.MyExn
+    IL_002f:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0034:  ceq
+    IL_0036:  ret
+
+    IL_0037:  ldc.i4.0
+    IL_0038:  ret
+
+    IL_0039:  ldc.i4.0
+    IL_003a:  ret
+
+    IL_003b:  ldarg.1
+    IL_003c:  ldnull
+    IL_003d:  cgt.un
+    IL_003f:  ldc.i4.0
+    IL_0040:  ceq
+    IL_0042:  ret
+  } 
+
+  .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (object V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0030
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_002e
+
+    IL_0006:  ldarg.1
+    IL_0007:  stloc.0
+    IL_0008:  ldloc.0
+    IL_0009:  isinst     XYZ.MyExn
+    IL_000e:  ldnull
+    IL_000f:  cgt.un
+    IL_0011:  brfalse.s  IL_002c
+
+    IL_0013:  ldarg.0
+    IL_0014:  castclass  XYZ.MyExn
+    IL_0019:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_001e:  ldarg.1
+    IL_001f:  castclass  XYZ.MyExn
+    IL_0024:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0029:  ceq
+    IL_002b:  ret
+
+    IL_002c:  ldc.i4.0
+    IL_002d:  ret
+
+    IL_002e:  ldc.i4.0
+    IL_002f:  ret
+
+    IL_0030:  ldarg.1
+    IL_0031:  ldnull
+    IL_0032:  cgt.un
+    IL_0034:  ldc.i4.0
+    IL_0035:  ceq
+    IL_0037:  ret
+  } 
+
+  .method public hidebysig virtual instance bool Equals(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  isinst     [runtime]System.Exception
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_0012
+
+    IL_000a:  ldarg.0
+    IL_000b:  ldloc.0
+    IL_000c:  callvirt   instance bool XYZ.MyExn::Equals(class [runtime]System.Exception)
+    IL_0011:  ret
+
+    IL_0012:  ldc.i4.0
+    IL_0013:  ret
+  } 
+
+  .property instance int32 Data0()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+    .get instance int32 XYZ.MyExn::get_Data0()
+  } 
+} 
+
+.class public auto ansi serializable XYZ.A
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .field assembly string x
+  .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  ldarg.1
+    IL_000a:  stfld      string XYZ.A::x
+    IL_000f:  ret
+  } 
+
+  .method public hidebysig specialname instance string get_X() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      string XYZ.A::x
+    IL_0006:  ret
+  } 
+
+  .property instance string X()
+  {
+    .get instance string XYZ.A::get_X()
+  } 
+} 
+
+.class public abstract auto ansi sealed XYZ.ABC
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Expr
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class XYZ.ABC/Expr>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class XYZ.ABC/Expr>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                         61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field assembly initonly int32 item
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public static class XYZ.ABC/Expr NewNum(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void XYZ.ABC/Expr::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+    {
+      .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                              class [runtime]System.Type) = ( 01 00 60 06 00 00 0C 58 59 5A 2E 41 42 43 2B 45   
+                                                                                                                                                     78 70 72 00 00 )                                  
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 XYZ.ABC/Expr::item
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Item() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/Expr>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class XYZ.ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_002f
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002d
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.0
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.1
+      IL_001a:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.3
+      IL_0022:  ldloc.s    V_4
+      IL_0024:  cgt
+      IL_0026:  ldloc.3
+      IL_0027:  ldloc.s    V_4
+      IL_0029:  clt
+      IL_002b:  sub
+      IL_002c:  ret
+
+      IL_002d:  ldc.i4.1
+      IL_002e:  ret
+
+      IL_002f:  ldarg.1
+      IL_0030:  brfalse.s  IL_0034
+
+      IL_0032:  ldc.i4.m1
+      IL_0033:  ret
+
+      IL_0034:  ldc.i4.0
+      IL_0035:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  XYZ.ABC/Expr
+      IL_0007:  callvirt   instance int32 XYZ.ABC/Expr::CompareTo(class XYZ.ABC/Expr)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class XYZ.ABC/Expr V_2,
+               class [runtime]System.Collections.IComparer V_3,
+               int32 V_4,
+               int32 V_5)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  XYZ.ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_003a
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  XYZ.ABC/Expr
+      IL_0010:  brfalse.s  IL_0038
+
+      IL_0012:  ldarg.0
+      IL_0013:  pop
+      IL_0014:  ldarg.0
+      IL_0015:  stloc.1
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  ldarg.2
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.1
+      IL_001b:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0020:  stloc.s    V_4
+      IL_0022:  ldloc.2
+      IL_0023:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0028:  stloc.s    V_5
+      IL_002a:  ldloc.s    V_4
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  cgt
+      IL_0030:  ldloc.s    V_4
+      IL_0032:  ldloc.s    V_5
+      IL_0034:  clt
+      IL_0036:  sub
+      IL_0037:  ret
+
+      IL_0038:  ldc.i4.1
+      IL_0039:  ret
+
+      IL_003a:  ldarg.1
+      IL_003b:  unbox.any  XYZ.ABC/Expr
+      IL_0040:  brfalse.s  IL_0044
+
+      IL_0042:  ldc.i4.m1
+      IL_0043:  ret
+
+      IL_0044:  ldc.i4.0
+      IL_0045:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class XYZ.ABC/Expr V_1,
+               class [runtime]System.Collections.IEqualityComparer V_2)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0024
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldarg.0
+      IL_0008:  stloc.1
+      IL_0009:  ldc.i4.0
+      IL_000a:  stloc.0
+      IL_000b:  ldc.i4     0x9e3779b9
+      IL_0010:  ldarg.1
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  ldloc.0
+      IL_0019:  ldc.i4.6
+      IL_001a:  shl
+      IL_001b:  ldloc.0
+      IL_001c:  ldc.i4.2
+      IL_001d:  shr
+      IL_001e:  add
+      IL_001f:  add
+      IL_0020:  add
+      IL_0021:  stloc.0
+      IL_0022:  ldloc.0
+      IL_0023:  ret
+
+      IL_0024:  ldc.i4.0
+      IL_0025:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 XYZ.ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class XYZ.ABC/Expr V_2,
+               class XYZ.ABC/Expr V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0029
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     XYZ.ABC/Expr
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0027
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  pop
+      IL_0011:  ldarg.0
+      IL_0012:  stloc.2
+      IL_0013:  ldloc.1
+      IL_0014:  stloc.3
+      IL_0015:  ldarg.2
+      IL_0016:  stloc.s    V_4
+      IL_0018:  ldloc.2
+      IL_0019:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_001e:  ldloc.3
+      IL_001f:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0024:  ceq
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+
+      IL_0029:  ldarg.1
+      IL_002a:  ldnull
+      IL_002b:  cgt.un
+      IL_002d:  ldc.i4.0
+      IL_002e:  ceq
+      IL_0030:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class XYZ.ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001d
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001b
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldloc.0
+      IL_000d:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  ceq
+      IL_001a:  ret
+
+      IL_001b:  ldc.i4.0
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  ldnull
+      IL_001f:  cgt.un
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     XYZ.ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool XYZ.ABC/Expr::Equals(class XYZ.ABC/Expr)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 XYZ.ABC/Expr::get_Tag()
+    } 
+    .property instance int32 Item()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .get instance int32 XYZ.ABC/Expr::get_Item()
+    } 
+  } 
+
+  .class auto ansi serializable nested public beforefieldinit MyExn
+         extends [runtime]System.Exception
+         implements [runtime]System.Collections.IStructuralEquatable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+    .field assembly int32 Data0@
+    .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 XYZ.ABC/MyExn::Data0@
+      IL_000d:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method family specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  ldarg.2
+      IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_Data0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 XYZ.ABC/MyExn::Data0@
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance string get_Message() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/MyExn>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/MyExn,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0023
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldc.i4     0x9e3779b9
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  castclass  XYZ.ABC/MyExn
+      IL_0012:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0017:  ldloc.0
+      IL_0018:  ldc.i4.6
+      IL_0019:  shl
+      IL_001a:  ldloc.0
+      IL_001b:  ldc.i4.2
+      IL_001c:  shr
+      IL_001d:  add
+      IL_001e:  add
+      IL_001f:  add
+      IL_0020:  stloc.0
+      IL_0021:  ldloc.0
+      IL_0022:  ret
+
+      IL_0023:  ldc.i4.0
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 XYZ.ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual instance bool 
+            Equals(object obj,
+                   class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1,
+               object V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_003b
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     [runtime]System.Exception
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0039
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldloc.0
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.2
+      IL_0012:  isinst     XYZ.ABC/MyExn
+      IL_0017:  ldnull
+      IL_0018:  cgt.un
+      IL_001a:  brfalse.s  IL_0037
+
+      IL_001c:  ldarg.2
+      IL_001d:  stloc.3
+      IL_001e:  ldarg.0
+      IL_001f:  castclass  XYZ.ABC/MyExn
+      IL_0024:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0029:  ldloc.1
+      IL_002a:  castclass  XYZ.ABC/MyExn
+      IL_002f:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0034:  ceq
+      IL_0036:  ret
+
+      IL_0037:  ldc.i4.0
+      IL_0038:  ret
+
+      IL_0039:  ldc.i4.0
+      IL_003a:  ret
+
+      IL_003b:  ldarg.1
+      IL_003c:  ldnull
+      IL_003d:  cgt.un
+      IL_003f:  ldc.i4.0
+      IL_0040:  ceq
+      IL_0042:  ret
+    } 
+
+    .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0030
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002e
+
+      IL_0006:  ldarg.1
+      IL_0007:  stloc.0
+      IL_0008:  ldloc.0
+      IL_0009:  isinst     XYZ.ABC/MyExn
+      IL_000e:  ldnull
+      IL_000f:  cgt.un
+      IL_0011:  brfalse.s  IL_002c
+
+      IL_0013:  ldarg.0
+      IL_0014:  castclass  XYZ.ABC/MyExn
+      IL_0019:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_001e:  ldarg.1
+      IL_001f:  castclass  XYZ.ABC/MyExn
+      IL_0024:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0029:  ceq
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+
+      IL_0030:  ldarg.1
+      IL_0031:  ldnull
+      IL_0032:  cgt.un
+      IL_0034:  ldc.i4.0
+      IL_0035:  ceq
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual instance bool Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     [runtime]System.Exception
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool XYZ.ABC/MyExn::Equals(class [runtime]System.Exception)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Data0()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance int32 XYZ.ABC/MyExn::get_Data0()
+    } 
+  } 
+
+  .class auto ansi serializable nested public A
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly string x
+    .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldarg.1
+      IL_000a:  stfld      string XYZ.ABC/A::x
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance string  get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string XYZ.ABC/A::x
+      IL_0006:  ret
+    } 
+
+    .property instance string X()
+    {
+      .get instance string XYZ.ABC/A::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public ABC
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested public beforefieldinit Expr
+           extends [runtime]System.Object
+           implements class [runtime]System.IEquatable`1<class XYZ.ABC/ABC/Expr>,
+                      [runtime]System.Collections.IStructuralEquatable,
+                      class [runtime]System.IComparable`1<class XYZ.ABC/ABC/Expr>,
+                      [runtime]System.IComparable,
+                      [runtime]System.Collections.IStructuralComparable
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                           61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public static class XYZ.ABC/ABC/Expr NewNum(int32 item) cil managed
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void XYZ.ABC/ABC/Expr::.ctor(int32)
+        IL_0006:  ret
+      } 
+
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 10 58 59 5A 2E 41 42 43 2B 41   
+                                                                                                                                                       42 43 2B 45 78 70 72 00 00 )                      
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Tag() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  pop
+        IL_0002:  ldc.i4.0
+        IL_0003:  ret
+      } 
+
+      .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+0.8A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public strict virtual instance string ToString() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/ABC/Expr>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(class XYZ.ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IComparer V_2,
+                 int32 V_3,
+                 int32 V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_002f
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002d
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.0
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.1
+        IL_001a:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_001f:  stloc.s    V_4
+        IL_0021:  ldloc.3
+        IL_0022:  ldloc.s    V_4
+        IL_0024:  cgt
+        IL_0026:  ldloc.3
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  clt
+        IL_002b:  sub
+        IL_002c:  ret
+
+        IL_002d:  ldc.i4.1
+        IL_002e:  ret
+
+        IL_002f:  ldarg.1
+        IL_0030:  brfalse.s  IL_0034
+
+        IL_0032:  ldc.i4.m1
+        IL_0033:  ret
+
+        IL_0034:  ldc.i4.0
+        IL_0035:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0007:  callvirt   instance int32 XYZ.ABC/ABC/Expr::CompareTo(class XYZ.ABC/ABC/Expr)
+        IL_000c:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance int32  CompareTo(object obj,
+                                        class [runtime]System.Collections.IComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class XYZ.ABC/ABC/Expr V_2,
+                 class [runtime]System.Collections.IComparer V_3,
+                 int32 V_4,
+                 int32 V_5)
+        IL_0000:  ldarg.1
+        IL_0001:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  brfalse.s  IL_003a
+
+        IL_000a:  ldarg.1
+        IL_000b:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0010:  brfalse.s  IL_0038
+
+        IL_0012:  ldarg.0
+        IL_0013:  pop
+        IL_0014:  ldarg.0
+        IL_0015:  stloc.1
+        IL_0016:  ldloc.0
+        IL_0017:  stloc.2
+        IL_0018:  ldarg.2
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.1
+        IL_001b:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0020:  stloc.s    V_4
+        IL_0022:  ldloc.2
+        IL_0023:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0028:  stloc.s    V_5
+        IL_002a:  ldloc.s    V_4
+        IL_002c:  ldloc.s    V_5
+        IL_002e:  cgt
+        IL_0030:  ldloc.s    V_4
+        IL_0032:  ldloc.s    V_5
+        IL_0034:  clt
+        IL_0036:  sub
+        IL_0037:  ret
+
+        IL_0038:  ldc.i4.1
+        IL_0039:  ret
+
+        IL_003a:  ldarg.1
+        IL_003b:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0040:  brfalse.s  IL_0044
+
+        IL_0042:  ldc.i4.m1
+        IL_0043:  ret
+
+        IL_0044:  ldc.i4.0
+        IL_0045:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IEqualityComparer V_2)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0024
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldarg.0
+        IL_0006:  pop
+        IL_0007:  ldarg.0
+        IL_0008:  stloc.1
+        IL_0009:  ldc.i4.0
+        IL_000a:  stloc.0
+        IL_000b:  ldc.i4     0x9e3779b9
+        IL_0010:  ldarg.1
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  ldloc.0
+        IL_0019:  ldc.i4.6
+        IL_001a:  shl
+        IL_001b:  ldloc.0
+        IL_001c:  ldc.i4.2
+        IL_001d:  shr
+        IL_001e:  add
+        IL_001f:  add
+        IL_0020:  add
+        IL_0021:  stloc.0
+        IL_0022:  ldloc.0
+        IL_0023:  ret
+
+        IL_0024:  ldc.i4.0
+        IL_0025:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 XYZ.ABC/ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance bool  Equals(object obj,
+                                    class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class XYZ.ABC/ABC/Expr V_2,
+                 class XYZ.ABC/ABC/Expr V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0029
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     XYZ.ABC/ABC/Expr
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0027
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldarg.0
+        IL_0010:  pop
+        IL_0011:  ldarg.0
+        IL_0012:  stloc.2
+        IL_0013:  ldloc.1
+        IL_0014:  stloc.3
+        IL_0015:  ldarg.2
+        IL_0016:  stloc.s    V_4
+        IL_0018:  ldloc.2
+        IL_0019:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_001e:  ldloc.3
+        IL_001f:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0024:  ceq
+        IL_0026:  ret
+
+        IL_0027:  ldc.i4.0
+        IL_0028:  ret
+
+        IL_0029:  ldarg.1
+        IL_002a:  ldnull
+        IL_002b:  cgt.un
+        IL_002d:  ldc.i4.0
+        IL_002e:  ceq
+        IL_0030:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(class XYZ.ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_001d
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_001b
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldloc.0
+        IL_000d:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  ceq
+        IL_001a:  ret
+
+        IL_001b:  ldc.i4.0
+        IL_001c:  ret
+
+        IL_001d:  ldarg.1
+        IL_001e:  ldnull
+        IL_001f:  cgt.un
+        IL_0021:  ldc.i4.0
+        IL_0022:  ceq
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     XYZ.ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool XYZ.ABC/ABC/Expr::Equals(class XYZ.ABC/ABC/Expr)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Tag()
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/Expr::get_Tag()
+      } 
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/Expr::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit MyExn
+           extends [runtime]System.Exception
+           implements [runtime]System.Collections.IStructuralEquatable
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+      .field assembly int32 Data0@
+      .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 XYZ.ABC/ABC/MyExn::Data0@
+        IL_000d:  ret
+      } 
+
+      .method public specialname rtspecialname instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method family specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  ldarg.2
+        IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+        IL_0008:  ret
+      } 
+
+      .method public hidebysig specialname instance int32  get_Data0() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 XYZ.ABC/ABC/MyExn::Data0@
+        IL_0006:  ret
+      } 
+
+      .method public strict virtual instance string get_Message() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/MyExn,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/ABC/MyExn>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/MyExn,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/MyExn,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [runtime]System.Collections.IEqualityComparer V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0023
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldc.i4     0x9e3779b9
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldarg.0
+        IL_000d:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0012:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0017:  ldloc.0
+        IL_0018:  ldc.i4.6
+        IL_0019:  shl
+        IL_001a:  ldloc.0
+        IL_001b:  ldc.i4.2
+        IL_001c:  shr
+        IL_001d:  add
+        IL_001e:  add
+        IL_001f:  add
+        IL_0020:  stloc.0
+        IL_0021:  ldloc.0
+        IL_0022:  ret
+
+        IL_0023:  ldc.i4.0
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 XYZ.ABC/ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual instance bool 
+              Equals(object obj,
+                     class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1,
+                 object V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_003b
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     [runtime]System.Exception
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0039
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldloc.0
+        IL_0010:  stloc.2
+        IL_0011:  ldloc.2
+        IL_0012:  isinst     XYZ.ABC/ABC/MyExn
+        IL_0017:  ldnull
+        IL_0018:  cgt.un
+        IL_001a:  brfalse.s  IL_0037
+
+        IL_001c:  ldarg.2
+        IL_001d:  stloc.3
+        IL_001e:  ldarg.0
+        IL_001f:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0024:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ldloc.1
+        IL_002a:  castclass  XYZ.ABC/ABC/MyExn
+        IL_002f:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0034:  ceq
+        IL_0036:  ret
+
+        IL_0037:  ldc.i4.0
+        IL_0038:  ret
+
+        IL_0039:  ldc.i4.0
+        IL_003a:  ret
+
+        IL_003b:  ldarg.1
+        IL_003c:  ldnull
+        IL_003d:  cgt.un
+        IL_003f:  ldc.i4.0
+        IL_0040:  ceq
+        IL_0042:  ret
+      } 
+
+      .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (object V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0030
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002e
+
+        IL_0006:  ldarg.1
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  isinst     XYZ.ABC/ABC/MyExn
+        IL_000e:  ldnull
+        IL_000f:  cgt.un
+        IL_0011:  brfalse.s  IL_002c
+
+        IL_0013:  ldarg.0
+        IL_0014:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0019:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_001e:  ldarg.1
+        IL_001f:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0024:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ceq
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+
+        IL_0030:  ldarg.1
+        IL_0031:  ldnull
+        IL_0032:  cgt.un
+        IL_0034:  ldc.i4.0
+        IL_0035:  ceq
+        IL_0037:  ret
+      } 
+
+      .method public hidebysig virtual instance bool Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     [runtime]System.Exception
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool XYZ.ABC/ABC/MyExn::Equals(class [runtime]System.Exception)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Data0()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+      } 
+    } 
+
+    .class auto ansi serializable nested public A
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+      .field assembly string x
+      .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  ldarg.1
+        IL_000a:  stfld      string XYZ.ABC/ABC/A::x
+        IL_000f:  ret
+      } 
+
+      .method public hidebysig specialname instance string  get_X() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      string XYZ.ABC/ABC/A::x
+        IL_0006:  ret
+      } 
+
+      .property instance string X()
+      {
+        .get instance string XYZ.ABC/ABC/A::get_X()
+      } 
+    } 
+
+    .method public static int32  'add'(int32 x,
+                                       int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public specialname static string get_greeting() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  ret
+    } 
+
+    .property string greeting()
+    {
+      .get string XYZ.ABC/ABC::get_greeting()
+    } 
+  } 
+
+  .method public static int32  'add'(int32 x,
+                                     int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public specialname static string get_greeting() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello"
+    IL_0005:  ret
+  } 
+
+  .property string greeting()
+  {
+    .get string XYZ.ABC::get_greeting()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOff.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOff.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOff.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOff.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOff.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOff.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOff.il.netcore.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOff.il.netcore.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOn.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOn.il.net472.debug.bsl
new file mode 100644
index 00000000000..755a63232ef
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOn.il.net472.debug.bsl
@@ -0,0 +1,2312 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public auto autochar serializable sealed beforefieldinit XYZ.Expr
+       extends [runtime]System.Object
+       implements class [runtime]System.IEquatable`1<class XYZ.Expr>,
+                  [runtime]System.Collections.IStructuralEquatable,
+                  class [runtime]System.IComparable`1<class XYZ.Expr>,
+                  [runtime]System.IComparable,
+                  [runtime]System.Collections.IStructuralComparable
+{
+  .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                 61 79 28 29 2C 6E 71 7D 00 00 )                   
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+  .field assembly initonly int32 item
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static class XYZ.Expr  NewNum(int32 item) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  newobj     instance void XYZ.Expr::.ctor(int32)
+    IL_0006:  ret
+  } 
+
+  .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+  {
+    .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                            class [runtime]System.Type) = ( 01 00 60 06 00 00 08 58 59 5A 2E 45 78 70 72 00   
+                                                                                                                             00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      int32 XYZ.Expr::item
+    IL_000d:  ret
+  } 
+
+  .method public hidebysig instance int32 get_Item() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      int32 XYZ.Expr::item
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig instance int32 get_Tag() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  pop
+    IL_0002:  ldc.i4.0
+    IL_0003:  ret
+  } 
+
+  .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+0.8A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public strict virtual instance string ToString() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.Expr>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  CompareTo(class XYZ.Expr obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class [runtime]System.Collections.IComparer V_2,
+             int32 V_3,
+             int32 V_4,
+             class [runtime]System.Collections.IComparer V_5,
+             int32 V_6,
+             int32 V_7)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_003b
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_0039
+
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  stloc.0
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.0
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.1
+    IL_001a:  ldfld      int32 XYZ.Expr::item
+    IL_001f:  stloc.s    V_4
+    IL_0021:  ldloc.2
+    IL_0022:  stloc.s    V_5
+    IL_0024:  ldloc.3
+    IL_0025:  stloc.s    V_6
+    IL_0027:  ldloc.s    V_4
+    IL_0029:  stloc.s    V_7
+    IL_002b:  ldloc.s    V_6
+    IL_002d:  ldloc.s    V_7
+    IL_002f:  cgt
+    IL_0031:  ldloc.s    V_6
+    IL_0033:  ldloc.s    V_7
+    IL_0035:  clt
+    IL_0037:  sub
+    IL_0038:  ret
+
+    IL_0039:  ldc.i4.1
+    IL_003a:  ret
+
+    IL_003b:  ldarg.1
+    IL_003c:  brfalse.s  IL_0040
+
+    IL_003e:  ldc.i4.m1
+    IL_003f:  ret
+
+    IL_0040:  ldc.i4.0
+    IL_0041:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  unbox.any  XYZ.Expr
+    IL_0007:  callvirt   instance int32 XYZ.Expr::CompareTo(class XYZ.Expr)
+    IL_000c:  ret
+  } 
+
+  .method public hidebysig virtual final 
+          instance int32  CompareTo(object obj,
+                                    class [runtime]System.Collections.IComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class XYZ.Expr V_2,
+             class [runtime]System.Collections.IComparer V_3,
+             int32 V_4,
+             int32 V_5,
+             class [runtime]System.Collections.IComparer V_6,
+             int32 V_7,
+             int32 V_8)
+    IL_0000:  ldarg.1
+    IL_0001:  unbox.any  XYZ.Expr
+    IL_0006:  stloc.0
+    IL_0007:  ldarg.0
+    IL_0008:  brfalse.s  IL_0045
+
+    IL_000a:  ldarg.1
+    IL_000b:  unbox.any  XYZ.Expr
+    IL_0010:  brfalse.s  IL_0043
+
+    IL_0012:  ldarg.0
+    IL_0013:  pop
+    IL_0014:  ldarg.0
+    IL_0015:  stloc.1
+    IL_0016:  ldloc.0
+    IL_0017:  stloc.2
+    IL_0018:  ldarg.2
+    IL_0019:  stloc.3
+    IL_001a:  ldloc.1
+    IL_001b:  ldfld      int32 XYZ.Expr::item
+    IL_0020:  stloc.s    V_4
+    IL_0022:  ldloc.2
+    IL_0023:  ldfld      int32 XYZ.Expr::item
+    IL_0028:  stloc.s    V_5
+    IL_002a:  ldloc.3
+    IL_002b:  stloc.s    V_6
+    IL_002d:  ldloc.s    V_4
+    IL_002f:  stloc.s    V_7
+    IL_0031:  ldloc.s    V_5
+    IL_0033:  stloc.s    V_8
+    IL_0035:  ldloc.s    V_7
+    IL_0037:  ldloc.s    V_8
+    IL_0039:  cgt
+    IL_003b:  ldloc.s    V_7
+    IL_003d:  ldloc.s    V_8
+    IL_003f:  clt
+    IL_0041:  sub
+    IL_0042:  ret
+
+    IL_0043:  ldc.i4.1
+    IL_0044:  ret
+
+    IL_0045:  ldarg.1
+    IL_0046:  unbox.any  XYZ.Expr
+    IL_004b:  brfalse.s  IL_004f
+
+    IL_004d:  ldc.i4.m1
+    IL_004e:  ret
+
+    IL_004f:  ldc.i4.0
+    IL_0050:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             class XYZ.Expr V_1,
+             class [runtime]System.Collections.IEqualityComparer V_2,
+             int32 V_3,
+             class [runtime]System.Collections.IEqualityComparer V_4)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0029
+
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.0
+    IL_0005:  ldarg.0
+    IL_0006:  pop
+    IL_0007:  ldarg.0
+    IL_0008:  stloc.1
+    IL_0009:  ldc.i4.0
+    IL_000a:  stloc.0
+    IL_000b:  ldc.i4     0x9e3779b9
+    IL_0010:  ldarg.1
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.1
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.2
+    IL_001a:  stloc.s    V_4
+    IL_001c:  ldloc.3
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.6
+    IL_001f:  shl
+    IL_0020:  ldloc.0
+    IL_0021:  ldc.i4.2
+    IL_0022:  shr
+    IL_0023:  add
+    IL_0024:  add
+    IL_0025:  add
+    IL_0026:  stloc.0
+    IL_0027:  ldloc.0
+    IL_0028:  ret
+
+    IL_0029:  ldc.i4.0
+    IL_002a:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0006:  callvirt   instance int32 XYZ.Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+    IL_000b:  ret
+  } 
+
+  .method public hidebysig virtual final 
+          instance bool  Equals(object obj,
+                                class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class XYZ.Expr V_2,
+             class XYZ.Expr V_3,
+             class [runtime]System.Collections.IEqualityComparer V_4,
+             int32 V_5,
+             int32 V_6,
+             class [runtime]System.Collections.IEqualityComparer V_7)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0035
+
+    IL_0003:  ldarg.1
+    IL_0004:  isinst     XYZ.Expr
+    IL_0009:  stloc.0
+    IL_000a:  ldloc.0
+    IL_000b:  brfalse.s  IL_0033
+
+    IL_000d:  ldloc.0
+    IL_000e:  stloc.1
+    IL_000f:  ldarg.0
+    IL_0010:  pop
+    IL_0011:  ldarg.0
+    IL_0012:  stloc.2
+    IL_0013:  ldloc.1
+    IL_0014:  stloc.3
+    IL_0015:  ldarg.2
+    IL_0016:  stloc.s    V_4
+    IL_0018:  ldloc.2
+    IL_0019:  ldfld      int32 XYZ.Expr::item
+    IL_001e:  stloc.s    V_5
+    IL_0020:  ldloc.3
+    IL_0021:  ldfld      int32 XYZ.Expr::item
+    IL_0026:  stloc.s    V_6
+    IL_0028:  ldloc.s    V_4
+    IL_002a:  stloc.s    V_7
+    IL_002c:  ldloc.s    V_5
+    IL_002e:  ldloc.s    V_6
+    IL_0030:  ceq
+    IL_0032:  ret
+
+    IL_0033:  ldc.i4.0
+    IL_0034:  ret
+
+    IL_0035:  ldarg.1
+    IL_0036:  ldnull
+    IL_0037:  cgt.un
+    IL_0039:  ldc.i4.0
+    IL_003a:  ceq
+    IL_003c:  ret
+  } 
+
+  .method public hidebysig virtual final instance bool  Equals(class XYZ.Expr obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_001d
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_001b
+
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  stloc.0
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  ldloc.0
+    IL_000d:  ldfld      int32 XYZ.Expr::item
+    IL_0012:  ldloc.1
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  ceq
+    IL_001a:  ret
+
+    IL_001b:  ldc.i4.0
+    IL_001c:  ret
+
+    IL_001d:  ldarg.1
+    IL_001e:  ldnull
+    IL_001f:  cgt.un
+    IL_0021:  ldc.i4.0
+    IL_0022:  ceq
+    IL_0024:  ret
+  } 
+
+  .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  isinst     XYZ.Expr
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_0012
+
+    IL_000a:  ldarg.0
+    IL_000b:  ldloc.0
+    IL_000c:  callvirt   instance bool XYZ.Expr::Equals(class XYZ.Expr)
+    IL_0011:  ret
+
+    IL_0012:  ldc.i4.0
+    IL_0013:  ret
+  } 
+
+  .property instance int32 Tag()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .get instance int32 XYZ.Expr::get_Tag()
+  } 
+  .property instance int32 Item()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32,
+                                                                                                int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance int32 XYZ.Expr::get_Item()
+  } 
+} 
+
+.class public auto ansi serializable beforefieldinit XYZ.MyExn
+       extends [runtime]System.Exception
+       implements [runtime]System.Collections.IStructuralEquatable
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+  .field assembly int32 Data0@
+  .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      int32 XYZ.MyExn::Data0@
+    IL_000d:  ret
+  } 
+
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+    IL_0006:  ret
+  } 
+
+  .method family specialname rtspecialname 
+          instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                               valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  ldarg.2
+    IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                         valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+    IL_0008:  ret
+  } 
+
+  .method public hidebysig specialname instance int32 get_Data0() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      int32 XYZ.MyExn::Data0@
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             class [runtime]System.Collections.IEqualityComparer V_1,
+             int32 V_2,
+             class [runtime]System.Collections.IEqualityComparer V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0027
+
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.0
+    IL_0005:  ldc.i4     0x9e3779b9
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  ldarg.0
+    IL_000d:  castclass  XYZ.MyExn
+    IL_0012:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0017:  stloc.2
+    IL_0018:  ldloc.1
+    IL_0019:  stloc.3
+    IL_001a:  ldloc.2
+    IL_001b:  ldloc.0
+    IL_001c:  ldc.i4.6
+    IL_001d:  shl
+    IL_001e:  ldloc.0
+    IL_001f:  ldc.i4.2
+    IL_0020:  shr
+    IL_0021:  add
+    IL_0022:  add
+    IL_0023:  add
+    IL_0024:  stloc.0
+    IL_0025:  ldloc.0
+    IL_0026:  ret
+
+    IL_0027:  ldc.i4.0
+    IL_0028:  ret
+  } 
+
+  .method public hidebysig virtual instance int32 GetHashCode() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0006:  callvirt   instance int32 XYZ.MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+    IL_000b:  ret
+  } 
+
+  .method public hidebysig virtual instance bool 
+          Equals(object obj,
+                 class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0,
+             class [runtime]System.Exception V_1,
+             object V_2,
+             class [runtime]System.Collections.IEqualityComparer V_3,
+             int32 V_4,
+             int32 V_5,
+             class [runtime]System.Collections.IEqualityComparer V_6)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0046
+
+    IL_0003:  ldarg.1
+    IL_0004:  isinst     [runtime]System.Exception
+    IL_0009:  stloc.0
+    IL_000a:  ldloc.0
+    IL_000b:  brfalse.s  IL_0044
+
+    IL_000d:  ldloc.0
+    IL_000e:  stloc.1
+    IL_000f:  ldloc.0
+    IL_0010:  stloc.2
+    IL_0011:  ldloc.2
+    IL_0012:  isinst     XYZ.MyExn
+    IL_0017:  ldnull
+    IL_0018:  cgt.un
+    IL_001a:  brfalse.s  IL_0042
+
+    IL_001c:  ldarg.2
+    IL_001d:  stloc.3
+    IL_001e:  ldarg.0
+    IL_001f:  castclass  XYZ.MyExn
+    IL_0024:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0029:  stloc.s    V_4
+    IL_002b:  ldloc.1
+    IL_002c:  castclass  XYZ.MyExn
+    IL_0031:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0036:  stloc.s    V_5
+    IL_0038:  ldloc.3
+    IL_0039:  stloc.s    V_6
+    IL_003b:  ldloc.s    V_4
+    IL_003d:  ldloc.s    V_5
+    IL_003f:  ceq
+    IL_0041:  ret
+
+    IL_0042:  ldc.i4.0
+    IL_0043:  ret
+
+    IL_0044:  ldc.i4.0
+    IL_0045:  ret
+
+    IL_0046:  ldarg.1
+    IL_0047:  ldnull
+    IL_0048:  cgt.un
+    IL_004a:  ldc.i4.0
+    IL_004b:  ceq
+    IL_004d:  ret
+  } 
+
+  .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (object V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0030
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_002e
+
+    IL_0006:  ldarg.1
+    IL_0007:  stloc.0
+    IL_0008:  ldloc.0
+    IL_0009:  isinst     XYZ.MyExn
+    IL_000e:  ldnull
+    IL_000f:  cgt.un
+    IL_0011:  brfalse.s  IL_002c
+
+    IL_0013:  ldarg.0
+    IL_0014:  castclass  XYZ.MyExn
+    IL_0019:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_001e:  ldarg.1
+    IL_001f:  castclass  XYZ.MyExn
+    IL_0024:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0029:  ceq
+    IL_002b:  ret
+
+    IL_002c:  ldc.i4.0
+    IL_002d:  ret
+
+    IL_002e:  ldc.i4.0
+    IL_002f:  ret
+
+    IL_0030:  ldarg.1
+    IL_0031:  ldnull
+    IL_0032:  cgt.un
+    IL_0034:  ldc.i4.0
+    IL_0035:  ceq
+    IL_0037:  ret
+  } 
+
+  .method public hidebysig virtual instance bool Equals(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  isinst     [runtime]System.Exception
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_0012
+
+    IL_000a:  ldarg.0
+    IL_000b:  ldloc.0
+    IL_000c:  callvirt   instance bool XYZ.MyExn::Equals(class [runtime]System.Exception)
+    IL_0011:  ret
+
+    IL_0012:  ldc.i4.0
+    IL_0013:  ret
+  } 
+
+  .property instance int32 Data0()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+    .get instance int32 XYZ.MyExn::get_Data0()
+  } 
+} 
+
+.class public auto ansi serializable XYZ.A
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .field assembly string x
+  .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  ldarg.1
+    IL_000a:  stfld      string XYZ.A::x
+    IL_000f:  ret
+  } 
+
+  .method public hidebysig specialname instance string get_X() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      string XYZ.A::x
+    IL_0006:  ret
+  } 
+
+  .property instance string X()
+  {
+    .get instance string XYZ.A::get_X()
+  } 
+} 
+
+.class public abstract auto ansi sealed XYZ.ABC
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Expr
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class XYZ.ABC/Expr>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class XYZ.ABC/Expr>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                   61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field assembly initonly int32 item
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public static class XYZ.ABC/Expr NewNum(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void XYZ.ABC/Expr::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+    {
+      .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                              class [runtime]System.Type) = ( 01 00 60 06 00 00 0C 58 59 5A 2E 41 42 43 2B 45   
+                                                                                                                               78 70 72 00 00 )                                  
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 XYZ.ABC/Expr::item
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Item() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/Expr>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class XYZ.ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4,
+               class [runtime]System.Collections.IComparer V_5,
+               int32 V_6,
+               int32 V_7)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_003b
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_0039
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.0
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.1
+      IL_001a:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.2
+      IL_0022:  stloc.s    V_5
+      IL_0024:  ldloc.3
+      IL_0025:  stloc.s    V_6
+      IL_0027:  ldloc.s    V_4
+      IL_0029:  stloc.s    V_7
+      IL_002b:  ldloc.s    V_6
+      IL_002d:  ldloc.s    V_7
+      IL_002f:  cgt
+      IL_0031:  ldloc.s    V_6
+      IL_0033:  ldloc.s    V_7
+      IL_0035:  clt
+      IL_0037:  sub
+      IL_0038:  ret
+
+      IL_0039:  ldc.i4.1
+      IL_003a:  ret
+
+      IL_003b:  ldarg.1
+      IL_003c:  brfalse.s  IL_0040
+
+      IL_003e:  ldc.i4.m1
+      IL_003f:  ret
+
+      IL_0040:  ldc.i4.0
+      IL_0041:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  XYZ.ABC/Expr
+      IL_0007:  callvirt   instance int32 XYZ.ABC/Expr::CompareTo(class XYZ.ABC/Expr)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class XYZ.ABC/Expr V_2,
+               class [runtime]System.Collections.IComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IComparer V_6,
+               int32 V_7,
+               int32 V_8)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  XYZ.ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_0045
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  XYZ.ABC/Expr
+      IL_0010:  brfalse.s  IL_0043
+
+      IL_0012:  ldarg.0
+      IL_0013:  pop
+      IL_0014:  ldarg.0
+      IL_0015:  stloc.1
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  ldarg.2
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.1
+      IL_001b:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0020:  stloc.s    V_4
+      IL_0022:  ldloc.2
+      IL_0023:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0028:  stloc.s    V_5
+      IL_002a:  ldloc.3
+      IL_002b:  stloc.s    V_6
+      IL_002d:  ldloc.s    V_4
+      IL_002f:  stloc.s    V_7
+      IL_0031:  ldloc.s    V_5
+      IL_0033:  stloc.s    V_8
+      IL_0035:  ldloc.s    V_7
+      IL_0037:  ldloc.s    V_8
+      IL_0039:  cgt
+      IL_003b:  ldloc.s    V_7
+      IL_003d:  ldloc.s    V_8
+      IL_003f:  clt
+      IL_0041:  sub
+      IL_0042:  ret
+
+      IL_0043:  ldc.i4.1
+      IL_0044:  ret
+
+      IL_0045:  ldarg.1
+      IL_0046:  unbox.any  XYZ.ABC/Expr
+      IL_004b:  brfalse.s  IL_004f
+
+      IL_004d:  ldc.i4.m1
+      IL_004e:  ret
+
+      IL_004f:  ldc.i4.0
+      IL_0050:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class XYZ.ABC/Expr V_1,
+               class [runtime]System.Collections.IEqualityComparer V_2,
+               int32 V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0029
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldarg.0
+      IL_0008:  stloc.1
+      IL_0009:  ldc.i4.0
+      IL_000a:  stloc.0
+      IL_000b:  ldc.i4     0x9e3779b9
+      IL_0010:  ldarg.1
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.2
+      IL_001a:  stloc.s    V_4
+      IL_001c:  ldloc.3
+      IL_001d:  ldloc.0
+      IL_001e:  ldc.i4.6
+      IL_001f:  shl
+      IL_0020:  ldloc.0
+      IL_0021:  ldc.i4.2
+      IL_0022:  shr
+      IL_0023:  add
+      IL_0024:  add
+      IL_0025:  add
+      IL_0026:  stloc.0
+      IL_0027:  ldloc.0
+      IL_0028:  ret
+
+      IL_0029:  ldc.i4.0
+      IL_002a:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 XYZ.ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class XYZ.ABC/Expr V_2,
+               class XYZ.ABC/Expr V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4,
+               int32 V_5,
+               int32 V_6,
+               class [runtime]System.Collections.IEqualityComparer V_7)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0035
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     XYZ.ABC/Expr
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0033
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  pop
+      IL_0011:  ldarg.0
+      IL_0012:  stloc.2
+      IL_0013:  ldloc.1
+      IL_0014:  stloc.3
+      IL_0015:  ldarg.2
+      IL_0016:  stloc.s    V_4
+      IL_0018:  ldloc.2
+      IL_0019:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_001e:  stloc.s    V_5
+      IL_0020:  ldloc.3
+      IL_0021:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0026:  stloc.s    V_6
+      IL_0028:  ldloc.s    V_4
+      IL_002a:  stloc.s    V_7
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  ldloc.s    V_6
+      IL_0030:  ceq
+      IL_0032:  ret
+
+      IL_0033:  ldc.i4.0
+      IL_0034:  ret
+
+      IL_0035:  ldarg.1
+      IL_0036:  ldnull
+      IL_0037:  cgt.un
+      IL_0039:  ldc.i4.0
+      IL_003a:  ceq
+      IL_003c:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class XYZ.ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001d
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001b
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldloc.0
+      IL_000d:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  ceq
+      IL_001a:  ret
+
+      IL_001b:  ldc.i4.0
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  ldnull
+      IL_001f:  cgt.un
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     XYZ.ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool XYZ.ABC/Expr::Equals(class XYZ.ABC/Expr)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 XYZ.ABC/Expr::get_Tag()
+    } 
+    .property instance int32 Item()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .get instance int32 XYZ.ABC/Expr::get_Item()
+    } 
+  } 
+
+  .class auto ansi serializable nested public beforefieldinit MyExn
+         extends [runtime]System.Exception
+         implements [runtime]System.Collections.IStructuralEquatable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+    .field assembly int32 Data0@
+    .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 XYZ.ABC/MyExn::Data0@
+      IL_000d:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method family specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  ldarg.2
+      IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                           valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_Data0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 XYZ.ABC/MyExn::Data0@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1,
+               int32 V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0027
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldc.i4     0x9e3779b9
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  castclass  XYZ.ABC/MyExn
+      IL_0012:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0017:  stloc.2
+      IL_0018:  ldloc.1
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.2
+      IL_001b:  ldloc.0
+      IL_001c:  ldc.i4.6
+      IL_001d:  shl
+      IL_001e:  ldloc.0
+      IL_001f:  ldc.i4.2
+      IL_0020:  shr
+      IL_0021:  add
+      IL_0022:  add
+      IL_0023:  add
+      IL_0024:  stloc.0
+      IL_0025:  ldloc.0
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 XYZ.ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual instance bool 
+            Equals(object obj,
+                   class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1,
+               object V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IEqualityComparer V_6)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0046
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     [runtime]System.Exception
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0044
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldloc.0
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.2
+      IL_0012:  isinst     XYZ.ABC/MyExn
+      IL_0017:  ldnull
+      IL_0018:  cgt.un
+      IL_001a:  brfalse.s  IL_0042
+
+      IL_001c:  ldarg.2
+      IL_001d:  stloc.3
+      IL_001e:  ldarg.0
+      IL_001f:  castclass  XYZ.ABC/MyExn
+      IL_0024:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0029:  stloc.s    V_4
+      IL_002b:  ldloc.1
+      IL_002c:  castclass  XYZ.ABC/MyExn
+      IL_0031:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0036:  stloc.s    V_5
+      IL_0038:  ldloc.3
+      IL_0039:  stloc.s    V_6
+      IL_003b:  ldloc.s    V_4
+      IL_003d:  ldloc.s    V_5
+      IL_003f:  ceq
+      IL_0041:  ret
+
+      IL_0042:  ldc.i4.0
+      IL_0043:  ret
+
+      IL_0044:  ldc.i4.0
+      IL_0045:  ret
+
+      IL_0046:  ldarg.1
+      IL_0047:  ldnull
+      IL_0048:  cgt.un
+      IL_004a:  ldc.i4.0
+      IL_004b:  ceq
+      IL_004d:  ret
+    } 
+
+    .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0030
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002e
+
+      IL_0006:  ldarg.1
+      IL_0007:  stloc.0
+      IL_0008:  ldloc.0
+      IL_0009:  isinst     XYZ.ABC/MyExn
+      IL_000e:  ldnull
+      IL_000f:  cgt.un
+      IL_0011:  brfalse.s  IL_002c
+
+      IL_0013:  ldarg.0
+      IL_0014:  castclass  XYZ.ABC/MyExn
+      IL_0019:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_001e:  ldarg.1
+      IL_001f:  castclass  XYZ.ABC/MyExn
+      IL_0024:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0029:  ceq
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+
+      IL_0030:  ldarg.1
+      IL_0031:  ldnull
+      IL_0032:  cgt.un
+      IL_0034:  ldc.i4.0
+      IL_0035:  ceq
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual instance bool Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     [runtime]System.Exception
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool XYZ.ABC/MyExn::Equals(class [runtime]System.Exception)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Data0()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance int32 XYZ.ABC/MyExn::get_Data0()
+    } 
+  } 
+
+  .class auto ansi serializable nested public A
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly string x
+    .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldarg.1
+      IL_000a:  stfld      string XYZ.ABC/A::x
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance string  get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string XYZ.ABC/A::x
+      IL_0006:  ret
+    } 
+
+    .property instance string X()
+    {
+      .get instance string XYZ.ABC/A::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public ABC
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested public beforefieldinit Expr
+           extends [runtime]System.Object
+           implements class [runtime]System.IEquatable`1<class XYZ.ABC/ABC/Expr>,
+                      [runtime]System.Collections.IStructuralEquatable,
+                      class [runtime]System.IComparable`1<class XYZ.ABC/ABC/Expr>,
+                      [runtime]System.IComparable,
+                      [runtime]System.Collections.IStructuralComparable
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                     61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public static class XYZ.ABC/ABC/Expr NewNum(int32 item) cil managed
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void XYZ.ABC/ABC/Expr::.ctor(int32)
+        IL_0006:  ret
+      } 
+
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 10 58 59 5A 2E 41 42 43 2B 41   
+                                                                                                                                 42 43 2B 45 78 70 72 00 00 )                      
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Tag() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  pop
+        IL_0002:  ldc.i4.0
+        IL_0003:  ret
+      } 
+
+      .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+0.8A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public strict virtual instance string ToString() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/ABC/Expr>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(class XYZ.ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IComparer V_2,
+                 int32 V_3,
+                 int32 V_4,
+                 class [runtime]System.Collections.IComparer V_5,
+                 int32 V_6,
+                 int32 V_7)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_003b
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_0039
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.0
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.1
+        IL_001a:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_001f:  stloc.s    V_4
+        IL_0021:  ldloc.2
+        IL_0022:  stloc.s    V_5
+        IL_0024:  ldloc.3
+        IL_0025:  stloc.s    V_6
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  stloc.s    V_7
+        IL_002b:  ldloc.s    V_6
+        IL_002d:  ldloc.s    V_7
+        IL_002f:  cgt
+        IL_0031:  ldloc.s    V_6
+        IL_0033:  ldloc.s    V_7
+        IL_0035:  clt
+        IL_0037:  sub
+        IL_0038:  ret
+
+        IL_0039:  ldc.i4.1
+        IL_003a:  ret
+
+        IL_003b:  ldarg.1
+        IL_003c:  brfalse.s  IL_0040
+
+        IL_003e:  ldc.i4.m1
+        IL_003f:  ret
+
+        IL_0040:  ldc.i4.0
+        IL_0041:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0007:  callvirt   instance int32 XYZ.ABC/ABC/Expr::CompareTo(class XYZ.ABC/ABC/Expr)
+        IL_000c:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance int32  CompareTo(object obj,
+                                        class [runtime]System.Collections.IComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class XYZ.ABC/ABC/Expr V_2,
+                 class [runtime]System.Collections.IComparer V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class [runtime]System.Collections.IComparer V_6,
+                 int32 V_7,
+                 int32 V_8)
+        IL_0000:  ldarg.1
+        IL_0001:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  brfalse.s  IL_0045
+
+        IL_000a:  ldarg.1
+        IL_000b:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0010:  brfalse.s  IL_0043
+
+        IL_0012:  ldarg.0
+        IL_0013:  pop
+        IL_0014:  ldarg.0
+        IL_0015:  stloc.1
+        IL_0016:  ldloc.0
+        IL_0017:  stloc.2
+        IL_0018:  ldarg.2
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.1
+        IL_001b:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0020:  stloc.s    V_4
+        IL_0022:  ldloc.2
+        IL_0023:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0028:  stloc.s    V_5
+        IL_002a:  ldloc.3
+        IL_002b:  stloc.s    V_6
+        IL_002d:  ldloc.s    V_4
+        IL_002f:  stloc.s    V_7
+        IL_0031:  ldloc.s    V_5
+        IL_0033:  stloc.s    V_8
+        IL_0035:  ldloc.s    V_7
+        IL_0037:  ldloc.s    V_8
+        IL_0039:  cgt
+        IL_003b:  ldloc.s    V_7
+        IL_003d:  ldloc.s    V_8
+        IL_003f:  clt
+        IL_0041:  sub
+        IL_0042:  ret
+
+        IL_0043:  ldc.i4.1
+        IL_0044:  ret
+
+        IL_0045:  ldarg.1
+        IL_0046:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_004b:  brfalse.s  IL_004f
+
+        IL_004d:  ldc.i4.m1
+        IL_004e:  ret
+
+        IL_004f:  ldc.i4.0
+        IL_0050:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IEqualityComparer V_2,
+                 int32 V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0029
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldarg.0
+        IL_0006:  pop
+        IL_0007:  ldarg.0
+        IL_0008:  stloc.1
+        IL_0009:  ldc.i4.0
+        IL_000a:  stloc.0
+        IL_000b:  ldc.i4     0x9e3779b9
+        IL_0010:  ldarg.1
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.2
+        IL_001a:  stloc.s    V_4
+        IL_001c:  ldloc.3
+        IL_001d:  ldloc.0
+        IL_001e:  ldc.i4.6
+        IL_001f:  shl
+        IL_0020:  ldloc.0
+        IL_0021:  ldc.i4.2
+        IL_0022:  shr
+        IL_0023:  add
+        IL_0024:  add
+        IL_0025:  add
+        IL_0026:  stloc.0
+        IL_0027:  ldloc.0
+        IL_0028:  ret
+
+        IL_0029:  ldc.i4.0
+        IL_002a:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 XYZ.ABC/ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance bool  Equals(object obj,
+                                    class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class XYZ.ABC/ABC/Expr V_2,
+                 class XYZ.ABC/ABC/Expr V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4,
+                 int32 V_5,
+                 int32 V_6,
+                 class [runtime]System.Collections.IEqualityComparer V_7)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0035
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     XYZ.ABC/ABC/Expr
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0033
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldarg.0
+        IL_0010:  pop
+        IL_0011:  ldarg.0
+        IL_0012:  stloc.2
+        IL_0013:  ldloc.1
+        IL_0014:  stloc.3
+        IL_0015:  ldarg.2
+        IL_0016:  stloc.s    V_4
+        IL_0018:  ldloc.2
+        IL_0019:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_001e:  stloc.s    V_5
+        IL_0020:  ldloc.3
+        IL_0021:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0026:  stloc.s    V_6
+        IL_0028:  ldloc.s    V_4
+        IL_002a:  stloc.s    V_7
+        IL_002c:  ldloc.s    V_5
+        IL_002e:  ldloc.s    V_6
+        IL_0030:  ceq
+        IL_0032:  ret
+
+        IL_0033:  ldc.i4.0
+        IL_0034:  ret
+
+        IL_0035:  ldarg.1
+        IL_0036:  ldnull
+        IL_0037:  cgt.un
+        IL_0039:  ldc.i4.0
+        IL_003a:  ceq
+        IL_003c:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(class XYZ.ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_001d
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_001b
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldloc.0
+        IL_000d:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  ceq
+        IL_001a:  ret
+
+        IL_001b:  ldc.i4.0
+        IL_001c:  ret
+
+        IL_001d:  ldarg.1
+        IL_001e:  ldnull
+        IL_001f:  cgt.un
+        IL_0021:  ldc.i4.0
+        IL_0022:  ceq
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     XYZ.ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool XYZ.ABC/ABC/Expr::Equals(class XYZ.ABC/ABC/Expr)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Tag()
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/Expr::get_Tag()
+      } 
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/Expr::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit MyExn
+           extends [runtime]System.Exception
+           implements [runtime]System.Collections.IStructuralEquatable
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+      .field assembly int32 Data0@
+      .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 XYZ.ABC/ABC/MyExn::Data0@
+        IL_000d:  ret
+      } 
+
+      .method public specialname rtspecialname instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method family specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  ldarg.2
+        IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                             valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+        IL_0008:  ret
+      } 
+
+      .method public hidebysig specialname instance int32  get_Data0() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 XYZ.ABC/ABC/MyExn::Data0@
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [runtime]System.Collections.IEqualityComparer V_1,
+                 int32 V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0027
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldc.i4     0x9e3779b9
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldarg.0
+        IL_000d:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0012:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0017:  stloc.2
+        IL_0018:  ldloc.1
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.2
+        IL_001b:  ldloc.0
+        IL_001c:  ldc.i4.6
+        IL_001d:  shl
+        IL_001e:  ldloc.0
+        IL_001f:  ldc.i4.2
+        IL_0020:  shr
+        IL_0021:  add
+        IL_0022:  add
+        IL_0023:  add
+        IL_0024:  stloc.0
+        IL_0025:  ldloc.0
+        IL_0026:  ret
+
+        IL_0027:  ldc.i4.0
+        IL_0028:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 XYZ.ABC/ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual instance bool 
+              Equals(object obj,
+                     class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1,
+                 object V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class [runtime]System.Collections.IEqualityComparer V_6)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0046
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     [runtime]System.Exception
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0044
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldloc.0
+        IL_0010:  stloc.2
+        IL_0011:  ldloc.2
+        IL_0012:  isinst     XYZ.ABC/ABC/MyExn
+        IL_0017:  ldnull
+        IL_0018:  cgt.un
+        IL_001a:  brfalse.s  IL_0042
+
+        IL_001c:  ldarg.2
+        IL_001d:  stloc.3
+        IL_001e:  ldarg.0
+        IL_001f:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0024:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0029:  stloc.s    V_4
+        IL_002b:  ldloc.1
+        IL_002c:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0031:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0036:  stloc.s    V_5
+        IL_0038:  ldloc.3
+        IL_0039:  stloc.s    V_6
+        IL_003b:  ldloc.s    V_4
+        IL_003d:  ldloc.s    V_5
+        IL_003f:  ceq
+        IL_0041:  ret
+
+        IL_0042:  ldc.i4.0
+        IL_0043:  ret
+
+        IL_0044:  ldc.i4.0
+        IL_0045:  ret
+
+        IL_0046:  ldarg.1
+        IL_0047:  ldnull
+        IL_0048:  cgt.un
+        IL_004a:  ldc.i4.0
+        IL_004b:  ceq
+        IL_004d:  ret
+      } 
+
+      .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (object V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0030
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002e
+
+        IL_0006:  ldarg.1
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  isinst     XYZ.ABC/ABC/MyExn
+        IL_000e:  ldnull
+        IL_000f:  cgt.un
+        IL_0011:  brfalse.s  IL_002c
+
+        IL_0013:  ldarg.0
+        IL_0014:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0019:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_001e:  ldarg.1
+        IL_001f:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0024:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ceq
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+
+        IL_0030:  ldarg.1
+        IL_0031:  ldnull
+        IL_0032:  cgt.un
+        IL_0034:  ldc.i4.0
+        IL_0035:  ceq
+        IL_0037:  ret
+      } 
+
+      .method public hidebysig virtual instance bool Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     [runtime]System.Exception
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool XYZ.ABC/ABC/MyExn::Equals(class [runtime]System.Exception)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Data0()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+      } 
+    } 
+
+    .class auto ansi serializable nested public A
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+      .field assembly string x
+      .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  ldarg.1
+        IL_000a:  stfld      string XYZ.ABC/ABC/A::x
+        IL_000f:  ret
+      } 
+
+      .method public hidebysig specialname instance string  get_X() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      string XYZ.ABC/ABC/A::x
+        IL_0006:  ret
+      } 
+
+      .property instance string X()
+      {
+        .get instance string XYZ.ABC/ABC/A::get_X()
+      } 
+    } 
+
+    .method public static int32  'add'(int32 x,
+                                       int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public specialname static string get_greeting() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  ret
+    } 
+
+    .property string greeting()
+    {
+      .get string XYZ.ABC/ABC::get_greeting()
+    } 
+  } 
+
+  .method public static int32  'add'(int32 x,
+                                     int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public specialname static string get_greeting() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello"
+    IL_0005:  ret
+  } 
+
+  .property string greeting()
+  {
+    .get string XYZ.ABC::get_greeting()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+.class private auto ansi serializable sealed System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+       extends [runtime]System.Enum
+{
+  .custom instance void [runtime]System.FlagsAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field public specialname rtspecialname int32 value__
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes All = int32(0xFFFFFFFF)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes None = int32(0x00000000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicParameterlessConstructor = int32(0x00000001)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicConstructors = int32(0x00000003)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicConstructors = int32(0x00000004)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicMethods = int32(0x00000008)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicMethods = int32(0x00000010)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicFields = int32(0x00000020)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicFields = int32(0x00000040)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicNestedTypes = int32(0x00000080)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicNestedTypes = int32(0x00000100)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicProperties = int32(0x00000200)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicProperties = int32(0x00000400)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicEvents = int32(0x00000800)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicEvents = int32(0x00001000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes Interfaces = int32(0x00002000)
+} 
+
+.class private auto ansi beforefieldinit System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute
+       extends [runtime]System.Attribute
+{
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private class [runtime]System.Type Type@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public specialname rtspecialname 
+          instance void  .ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType,
+                               class [runtime]System.Type Type) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Attribute::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_000d:  ldarg.0
+    IL_000e:  ldarg.2
+    IL_000f:  stfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0014:  ret
+  } 
+
+  .method public hidebysig specialname instance class [runtime]System.Type get_Type() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes get_MemberType() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_0006:  ret
+  } 
+
+  .property instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+          MemberType()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_MemberType()
+  } 
+  .property instance class [runtime]System.Type
+          Type()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_Type()
+  } 
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOn.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOn.il.net472.release.bsl
new file mode 100644
index 00000000000..aa3fff8667d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOn.il.net472.release.bsl
@@ -0,0 +1,2168 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public auto autochar serializable sealed beforefieldinit XYZ.Expr
+       extends [runtime]System.Object
+       implements class [runtime]System.IEquatable`1<class XYZ.Expr>,
+                  [runtime]System.Collections.IStructuralEquatable,
+                  class [runtime]System.IComparable`1<class XYZ.Expr>,
+                  [runtime]System.IComparable,
+                  [runtime]System.Collections.IStructuralComparable
+{
+  .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                 61 79 28 29 2C 6E 71 7D 00 00 )                   
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+  .field assembly initonly int32 item
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static class XYZ.Expr  NewNum(int32 item) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  newobj     instance void XYZ.Expr::.ctor(int32)
+    IL_0006:  ret
+  } 
+
+  .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+  {
+    .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                            class [runtime]System.Type) = ( 01 00 60 06 00 00 08 58 59 5A 2E 45 78 70 72 00   
+                                                                                                                             00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      int32 XYZ.Expr::item
+    IL_000d:  ret
+  } 
+
+  .method public hidebysig instance int32 get_Item() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      int32 XYZ.Expr::item
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig instance int32 get_Tag() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  pop
+    IL_0002:  ldc.i4.0
+    IL_0003:  ret
+  } 
+
+  .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+0.8A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public strict virtual instance string ToString() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.Expr>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  CompareTo(class XYZ.Expr obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class [runtime]System.Collections.IComparer V_2,
+             int32 V_3,
+             int32 V_4)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_002f
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_002d
+
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  stloc.0
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.0
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.1
+    IL_001a:  ldfld      int32 XYZ.Expr::item
+    IL_001f:  stloc.s    V_4
+    IL_0021:  ldloc.3
+    IL_0022:  ldloc.s    V_4
+    IL_0024:  cgt
+    IL_0026:  ldloc.3
+    IL_0027:  ldloc.s    V_4
+    IL_0029:  clt
+    IL_002b:  sub
+    IL_002c:  ret
+
+    IL_002d:  ldc.i4.1
+    IL_002e:  ret
+
+    IL_002f:  ldarg.1
+    IL_0030:  brfalse.s  IL_0034
+
+    IL_0032:  ldc.i4.m1
+    IL_0033:  ret
+
+    IL_0034:  ldc.i4.0
+    IL_0035:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  unbox.any  XYZ.Expr
+    IL_0007:  callvirt   instance int32 XYZ.Expr::CompareTo(class XYZ.Expr)
+    IL_000c:  ret
+  } 
+
+  .method public hidebysig virtual final 
+          instance int32  CompareTo(object obj,
+                                    class [runtime]System.Collections.IComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class XYZ.Expr V_2,
+             class [runtime]System.Collections.IComparer V_3,
+             int32 V_4,
+             int32 V_5)
+    IL_0000:  ldarg.1
+    IL_0001:  unbox.any  XYZ.Expr
+    IL_0006:  stloc.0
+    IL_0007:  ldarg.0
+    IL_0008:  brfalse.s  IL_003a
+
+    IL_000a:  ldarg.1
+    IL_000b:  unbox.any  XYZ.Expr
+    IL_0010:  brfalse.s  IL_0038
+
+    IL_0012:  ldarg.0
+    IL_0013:  pop
+    IL_0014:  ldarg.0
+    IL_0015:  stloc.1
+    IL_0016:  ldloc.0
+    IL_0017:  stloc.2
+    IL_0018:  ldarg.2
+    IL_0019:  stloc.3
+    IL_001a:  ldloc.1
+    IL_001b:  ldfld      int32 XYZ.Expr::item
+    IL_0020:  stloc.s    V_4
+    IL_0022:  ldloc.2
+    IL_0023:  ldfld      int32 XYZ.Expr::item
+    IL_0028:  stloc.s    V_5
+    IL_002a:  ldloc.s    V_4
+    IL_002c:  ldloc.s    V_5
+    IL_002e:  cgt
+    IL_0030:  ldloc.s    V_4
+    IL_0032:  ldloc.s    V_5
+    IL_0034:  clt
+    IL_0036:  sub
+    IL_0037:  ret
+
+    IL_0038:  ldc.i4.1
+    IL_0039:  ret
+
+    IL_003a:  ldarg.1
+    IL_003b:  unbox.any  XYZ.Expr
+    IL_0040:  brfalse.s  IL_0044
+
+    IL_0042:  ldc.i4.m1
+    IL_0043:  ret
+
+    IL_0044:  ldc.i4.0
+    IL_0045:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             class XYZ.Expr V_1,
+             class [runtime]System.Collections.IEqualityComparer V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0024
+
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.0
+    IL_0005:  ldarg.0
+    IL_0006:  pop
+    IL_0007:  ldarg.0
+    IL_0008:  stloc.1
+    IL_0009:  ldc.i4.0
+    IL_000a:  stloc.0
+    IL_000b:  ldc.i4     0x9e3779b9
+    IL_0010:  ldarg.1
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.1
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  ldloc.0
+    IL_0019:  ldc.i4.6
+    IL_001a:  shl
+    IL_001b:  ldloc.0
+    IL_001c:  ldc.i4.2
+    IL_001d:  shr
+    IL_001e:  add
+    IL_001f:  add
+    IL_0020:  add
+    IL_0021:  stloc.0
+    IL_0022:  ldloc.0
+    IL_0023:  ret
+
+    IL_0024:  ldc.i4.0
+    IL_0025:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0006:  callvirt   instance int32 XYZ.Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+    IL_000b:  ret
+  } 
+
+  .method public hidebysig virtual final 
+          instance bool  Equals(object obj,
+                                class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class XYZ.Expr V_2,
+             class XYZ.Expr V_3,
+             class [runtime]System.Collections.IEqualityComparer V_4)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0029
+
+    IL_0003:  ldarg.1
+    IL_0004:  isinst     XYZ.Expr
+    IL_0009:  stloc.0
+    IL_000a:  ldloc.0
+    IL_000b:  brfalse.s  IL_0027
+
+    IL_000d:  ldloc.0
+    IL_000e:  stloc.1
+    IL_000f:  ldarg.0
+    IL_0010:  pop
+    IL_0011:  ldarg.0
+    IL_0012:  stloc.2
+    IL_0013:  ldloc.1
+    IL_0014:  stloc.3
+    IL_0015:  ldarg.2
+    IL_0016:  stloc.s    V_4
+    IL_0018:  ldloc.2
+    IL_0019:  ldfld      int32 XYZ.Expr::item
+    IL_001e:  ldloc.3
+    IL_001f:  ldfld      int32 XYZ.Expr::item
+    IL_0024:  ceq
+    IL_0026:  ret
+
+    IL_0027:  ldc.i4.0
+    IL_0028:  ret
+
+    IL_0029:  ldarg.1
+    IL_002a:  ldnull
+    IL_002b:  cgt.un
+    IL_002d:  ldc.i4.0
+    IL_002e:  ceq
+    IL_0030:  ret
+  } 
+
+  .method public hidebysig virtual final instance bool  Equals(class XYZ.Expr obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_001d
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_001b
+
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  stloc.0
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  ldloc.0
+    IL_000d:  ldfld      int32 XYZ.Expr::item
+    IL_0012:  ldloc.1
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  ceq
+    IL_001a:  ret
+
+    IL_001b:  ldc.i4.0
+    IL_001c:  ret
+
+    IL_001d:  ldarg.1
+    IL_001e:  ldnull
+    IL_001f:  cgt.un
+    IL_0021:  ldc.i4.0
+    IL_0022:  ceq
+    IL_0024:  ret
+  } 
+
+  .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  isinst     XYZ.Expr
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_0012
+
+    IL_000a:  ldarg.0
+    IL_000b:  ldloc.0
+    IL_000c:  callvirt   instance bool XYZ.Expr::Equals(class XYZ.Expr)
+    IL_0011:  ret
+
+    IL_0012:  ldc.i4.0
+    IL_0013:  ret
+  } 
+
+  .property instance int32 Tag()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .get instance int32 XYZ.Expr::get_Tag()
+  } 
+  .property instance int32 Item()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32,
+                                                                                                int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance int32 XYZ.Expr::get_Item()
+  } 
+} 
+
+.class public auto ansi serializable beforefieldinit XYZ.MyExn
+       extends [runtime]System.Exception
+       implements [runtime]System.Collections.IStructuralEquatable
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+  .field assembly int32 Data0@
+  .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      int32 XYZ.MyExn::Data0@
+    IL_000d:  ret
+  } 
+
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+    IL_0006:  ret
+  } 
+
+  .method family specialname rtspecialname 
+          instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                               valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  ldarg.2
+    IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                         valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+    IL_0008:  ret
+  } 
+
+  .method public hidebysig specialname instance int32 get_Data0() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      int32 XYZ.MyExn::Data0@
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             class [runtime]System.Collections.IEqualityComparer V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0023
+
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.0
+    IL_0005:  ldc.i4     0x9e3779b9
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  ldarg.0
+    IL_000d:  castclass  XYZ.MyExn
+    IL_0012:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0017:  ldloc.0
+    IL_0018:  ldc.i4.6
+    IL_0019:  shl
+    IL_001a:  ldloc.0
+    IL_001b:  ldc.i4.2
+    IL_001c:  shr
+    IL_001d:  add
+    IL_001e:  add
+    IL_001f:  add
+    IL_0020:  stloc.0
+    IL_0021:  ldloc.0
+    IL_0022:  ret
+
+    IL_0023:  ldc.i4.0
+    IL_0024:  ret
+  } 
+
+  .method public hidebysig virtual instance int32 GetHashCode() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0006:  callvirt   instance int32 XYZ.MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+    IL_000b:  ret
+  } 
+
+  .method public hidebysig virtual instance bool 
+          Equals(object obj,
+                 class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0,
+             class [runtime]System.Exception V_1,
+             object V_2,
+             class [runtime]System.Collections.IEqualityComparer V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_003b
+
+    IL_0003:  ldarg.1
+    IL_0004:  isinst     [runtime]System.Exception
+    IL_0009:  stloc.0
+    IL_000a:  ldloc.0
+    IL_000b:  brfalse.s  IL_0039
+
+    IL_000d:  ldloc.0
+    IL_000e:  stloc.1
+    IL_000f:  ldloc.0
+    IL_0010:  stloc.2
+    IL_0011:  ldloc.2
+    IL_0012:  isinst     XYZ.MyExn
+    IL_0017:  ldnull
+    IL_0018:  cgt.un
+    IL_001a:  brfalse.s  IL_0037
+
+    IL_001c:  ldarg.2
+    IL_001d:  stloc.3
+    IL_001e:  ldarg.0
+    IL_001f:  castclass  XYZ.MyExn
+    IL_0024:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0029:  ldloc.1
+    IL_002a:  castclass  XYZ.MyExn
+    IL_002f:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0034:  ceq
+    IL_0036:  ret
+
+    IL_0037:  ldc.i4.0
+    IL_0038:  ret
+
+    IL_0039:  ldc.i4.0
+    IL_003a:  ret
+
+    IL_003b:  ldarg.1
+    IL_003c:  ldnull
+    IL_003d:  cgt.un
+    IL_003f:  ldc.i4.0
+    IL_0040:  ceq
+    IL_0042:  ret
+  } 
+
+  .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (object V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0030
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_002e
+
+    IL_0006:  ldarg.1
+    IL_0007:  stloc.0
+    IL_0008:  ldloc.0
+    IL_0009:  isinst     XYZ.MyExn
+    IL_000e:  ldnull
+    IL_000f:  cgt.un
+    IL_0011:  brfalse.s  IL_002c
+
+    IL_0013:  ldarg.0
+    IL_0014:  castclass  XYZ.MyExn
+    IL_0019:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_001e:  ldarg.1
+    IL_001f:  castclass  XYZ.MyExn
+    IL_0024:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0029:  ceq
+    IL_002b:  ret
+
+    IL_002c:  ldc.i4.0
+    IL_002d:  ret
+
+    IL_002e:  ldc.i4.0
+    IL_002f:  ret
+
+    IL_0030:  ldarg.1
+    IL_0031:  ldnull
+    IL_0032:  cgt.un
+    IL_0034:  ldc.i4.0
+    IL_0035:  ceq
+    IL_0037:  ret
+  } 
+
+  .method public hidebysig virtual instance bool Equals(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  isinst     [runtime]System.Exception
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_0012
+
+    IL_000a:  ldarg.0
+    IL_000b:  ldloc.0
+    IL_000c:  callvirt   instance bool XYZ.MyExn::Equals(class [runtime]System.Exception)
+    IL_0011:  ret
+
+    IL_0012:  ldc.i4.0
+    IL_0013:  ret
+  } 
+
+  .property instance int32 Data0()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+    .get instance int32 XYZ.MyExn::get_Data0()
+  } 
+} 
+
+.class public auto ansi serializable XYZ.A
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .field assembly string x
+  .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  ldarg.1
+    IL_000a:  stfld      string XYZ.A::x
+    IL_000f:  ret
+  } 
+
+  .method public hidebysig specialname instance string get_X() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      string XYZ.A::x
+    IL_0006:  ret
+  } 
+
+  .property instance string X()
+  {
+    .get instance string XYZ.A::get_X()
+  } 
+} 
+
+.class public abstract auto ansi sealed XYZ.ABC
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Expr
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class XYZ.ABC/Expr>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class XYZ.ABC/Expr>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                   61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field assembly initonly int32 item
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public static class XYZ.ABC/Expr NewNum(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void XYZ.ABC/Expr::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+    {
+      .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                              class [runtime]System.Type) = ( 01 00 60 06 00 00 0C 58 59 5A 2E 41 42 43 2B 45   
+                                                                                                                               78 70 72 00 00 )                                  
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 XYZ.ABC/Expr::item
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Item() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/Expr>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class XYZ.ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_002f
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002d
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.0
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.1
+      IL_001a:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.3
+      IL_0022:  ldloc.s    V_4
+      IL_0024:  cgt
+      IL_0026:  ldloc.3
+      IL_0027:  ldloc.s    V_4
+      IL_0029:  clt
+      IL_002b:  sub
+      IL_002c:  ret
+
+      IL_002d:  ldc.i4.1
+      IL_002e:  ret
+
+      IL_002f:  ldarg.1
+      IL_0030:  brfalse.s  IL_0034
+
+      IL_0032:  ldc.i4.m1
+      IL_0033:  ret
+
+      IL_0034:  ldc.i4.0
+      IL_0035:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  XYZ.ABC/Expr
+      IL_0007:  callvirt   instance int32 XYZ.ABC/Expr::CompareTo(class XYZ.ABC/Expr)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class XYZ.ABC/Expr V_2,
+               class [runtime]System.Collections.IComparer V_3,
+               int32 V_4,
+               int32 V_5)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  XYZ.ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_003a
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  XYZ.ABC/Expr
+      IL_0010:  brfalse.s  IL_0038
+
+      IL_0012:  ldarg.0
+      IL_0013:  pop
+      IL_0014:  ldarg.0
+      IL_0015:  stloc.1
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  ldarg.2
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.1
+      IL_001b:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0020:  stloc.s    V_4
+      IL_0022:  ldloc.2
+      IL_0023:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0028:  stloc.s    V_5
+      IL_002a:  ldloc.s    V_4
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  cgt
+      IL_0030:  ldloc.s    V_4
+      IL_0032:  ldloc.s    V_5
+      IL_0034:  clt
+      IL_0036:  sub
+      IL_0037:  ret
+
+      IL_0038:  ldc.i4.1
+      IL_0039:  ret
+
+      IL_003a:  ldarg.1
+      IL_003b:  unbox.any  XYZ.ABC/Expr
+      IL_0040:  brfalse.s  IL_0044
+
+      IL_0042:  ldc.i4.m1
+      IL_0043:  ret
+
+      IL_0044:  ldc.i4.0
+      IL_0045:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class XYZ.ABC/Expr V_1,
+               class [runtime]System.Collections.IEqualityComparer V_2)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0024
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldarg.0
+      IL_0008:  stloc.1
+      IL_0009:  ldc.i4.0
+      IL_000a:  stloc.0
+      IL_000b:  ldc.i4     0x9e3779b9
+      IL_0010:  ldarg.1
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  ldloc.0
+      IL_0019:  ldc.i4.6
+      IL_001a:  shl
+      IL_001b:  ldloc.0
+      IL_001c:  ldc.i4.2
+      IL_001d:  shr
+      IL_001e:  add
+      IL_001f:  add
+      IL_0020:  add
+      IL_0021:  stloc.0
+      IL_0022:  ldloc.0
+      IL_0023:  ret
+
+      IL_0024:  ldc.i4.0
+      IL_0025:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 XYZ.ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class XYZ.ABC/Expr V_2,
+               class XYZ.ABC/Expr V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0029
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     XYZ.ABC/Expr
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0027
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  pop
+      IL_0011:  ldarg.0
+      IL_0012:  stloc.2
+      IL_0013:  ldloc.1
+      IL_0014:  stloc.3
+      IL_0015:  ldarg.2
+      IL_0016:  stloc.s    V_4
+      IL_0018:  ldloc.2
+      IL_0019:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_001e:  ldloc.3
+      IL_001f:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0024:  ceq
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+
+      IL_0029:  ldarg.1
+      IL_002a:  ldnull
+      IL_002b:  cgt.un
+      IL_002d:  ldc.i4.0
+      IL_002e:  ceq
+      IL_0030:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class XYZ.ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001d
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001b
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldloc.0
+      IL_000d:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  ceq
+      IL_001a:  ret
+
+      IL_001b:  ldc.i4.0
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  ldnull
+      IL_001f:  cgt.un
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     XYZ.ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool XYZ.ABC/Expr::Equals(class XYZ.ABC/Expr)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 XYZ.ABC/Expr::get_Tag()
+    } 
+    .property instance int32 Item()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .get instance int32 XYZ.ABC/Expr::get_Item()
+    } 
+  } 
+
+  .class auto ansi serializable nested public beforefieldinit MyExn
+         extends [runtime]System.Exception
+         implements [runtime]System.Collections.IStructuralEquatable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+    .field assembly int32 Data0@
+    .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 XYZ.ABC/MyExn::Data0@
+      IL_000d:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method family specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  ldarg.2
+      IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                           valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_Data0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 XYZ.ABC/MyExn::Data0@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0023
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldc.i4     0x9e3779b9
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  castclass  XYZ.ABC/MyExn
+      IL_0012:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0017:  ldloc.0
+      IL_0018:  ldc.i4.6
+      IL_0019:  shl
+      IL_001a:  ldloc.0
+      IL_001b:  ldc.i4.2
+      IL_001c:  shr
+      IL_001d:  add
+      IL_001e:  add
+      IL_001f:  add
+      IL_0020:  stloc.0
+      IL_0021:  ldloc.0
+      IL_0022:  ret
+
+      IL_0023:  ldc.i4.0
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 XYZ.ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual instance bool 
+            Equals(object obj,
+                   class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1,
+               object V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_003b
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     [runtime]System.Exception
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0039
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldloc.0
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.2
+      IL_0012:  isinst     XYZ.ABC/MyExn
+      IL_0017:  ldnull
+      IL_0018:  cgt.un
+      IL_001a:  brfalse.s  IL_0037
+
+      IL_001c:  ldarg.2
+      IL_001d:  stloc.3
+      IL_001e:  ldarg.0
+      IL_001f:  castclass  XYZ.ABC/MyExn
+      IL_0024:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0029:  ldloc.1
+      IL_002a:  castclass  XYZ.ABC/MyExn
+      IL_002f:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0034:  ceq
+      IL_0036:  ret
+
+      IL_0037:  ldc.i4.0
+      IL_0038:  ret
+
+      IL_0039:  ldc.i4.0
+      IL_003a:  ret
+
+      IL_003b:  ldarg.1
+      IL_003c:  ldnull
+      IL_003d:  cgt.un
+      IL_003f:  ldc.i4.0
+      IL_0040:  ceq
+      IL_0042:  ret
+    } 
+
+    .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0030
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002e
+
+      IL_0006:  ldarg.1
+      IL_0007:  stloc.0
+      IL_0008:  ldloc.0
+      IL_0009:  isinst     XYZ.ABC/MyExn
+      IL_000e:  ldnull
+      IL_000f:  cgt.un
+      IL_0011:  brfalse.s  IL_002c
+
+      IL_0013:  ldarg.0
+      IL_0014:  castclass  XYZ.ABC/MyExn
+      IL_0019:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_001e:  ldarg.1
+      IL_001f:  castclass  XYZ.ABC/MyExn
+      IL_0024:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0029:  ceq
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+
+      IL_0030:  ldarg.1
+      IL_0031:  ldnull
+      IL_0032:  cgt.un
+      IL_0034:  ldc.i4.0
+      IL_0035:  ceq
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual instance bool Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     [runtime]System.Exception
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool XYZ.ABC/MyExn::Equals(class [runtime]System.Exception)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Data0()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance int32 XYZ.ABC/MyExn::get_Data0()
+    } 
+  } 
+
+  .class auto ansi serializable nested public A
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly string x
+    .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldarg.1
+      IL_000a:  stfld      string XYZ.ABC/A::x
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance string  get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string XYZ.ABC/A::x
+      IL_0006:  ret
+    } 
+
+    .property instance string X()
+    {
+      .get instance string XYZ.ABC/A::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public ABC
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested public beforefieldinit Expr
+           extends [runtime]System.Object
+           implements class [runtime]System.IEquatable`1<class XYZ.ABC/ABC/Expr>,
+                      [runtime]System.Collections.IStructuralEquatable,
+                      class [runtime]System.IComparable`1<class XYZ.ABC/ABC/Expr>,
+                      [runtime]System.IComparable,
+                      [runtime]System.Collections.IStructuralComparable
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                     61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public static class XYZ.ABC/ABC/Expr NewNum(int32 item) cil managed
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void XYZ.ABC/ABC/Expr::.ctor(int32)
+        IL_0006:  ret
+      } 
+
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 10 58 59 5A 2E 41 42 43 2B 41   
+                                                                                                                                 42 43 2B 45 78 70 72 00 00 )                      
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Tag() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  pop
+        IL_0002:  ldc.i4.0
+        IL_0003:  ret
+      } 
+
+      .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+0.8A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public strict virtual instance string ToString() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/ABC/Expr>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(class XYZ.ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IComparer V_2,
+                 int32 V_3,
+                 int32 V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_002f
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002d
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.0
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.1
+        IL_001a:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_001f:  stloc.s    V_4
+        IL_0021:  ldloc.3
+        IL_0022:  ldloc.s    V_4
+        IL_0024:  cgt
+        IL_0026:  ldloc.3
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  clt
+        IL_002b:  sub
+        IL_002c:  ret
+
+        IL_002d:  ldc.i4.1
+        IL_002e:  ret
+
+        IL_002f:  ldarg.1
+        IL_0030:  brfalse.s  IL_0034
+
+        IL_0032:  ldc.i4.m1
+        IL_0033:  ret
+
+        IL_0034:  ldc.i4.0
+        IL_0035:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0007:  callvirt   instance int32 XYZ.ABC/ABC/Expr::CompareTo(class XYZ.ABC/ABC/Expr)
+        IL_000c:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance int32  CompareTo(object obj,
+                                        class [runtime]System.Collections.IComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class XYZ.ABC/ABC/Expr V_2,
+                 class [runtime]System.Collections.IComparer V_3,
+                 int32 V_4,
+                 int32 V_5)
+        IL_0000:  ldarg.1
+        IL_0001:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  brfalse.s  IL_003a
+
+        IL_000a:  ldarg.1
+        IL_000b:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0010:  brfalse.s  IL_0038
+
+        IL_0012:  ldarg.0
+        IL_0013:  pop
+        IL_0014:  ldarg.0
+        IL_0015:  stloc.1
+        IL_0016:  ldloc.0
+        IL_0017:  stloc.2
+        IL_0018:  ldarg.2
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.1
+        IL_001b:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0020:  stloc.s    V_4
+        IL_0022:  ldloc.2
+        IL_0023:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0028:  stloc.s    V_5
+        IL_002a:  ldloc.s    V_4
+        IL_002c:  ldloc.s    V_5
+        IL_002e:  cgt
+        IL_0030:  ldloc.s    V_4
+        IL_0032:  ldloc.s    V_5
+        IL_0034:  clt
+        IL_0036:  sub
+        IL_0037:  ret
+
+        IL_0038:  ldc.i4.1
+        IL_0039:  ret
+
+        IL_003a:  ldarg.1
+        IL_003b:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0040:  brfalse.s  IL_0044
+
+        IL_0042:  ldc.i4.m1
+        IL_0043:  ret
+
+        IL_0044:  ldc.i4.0
+        IL_0045:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IEqualityComparer V_2)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0024
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldarg.0
+        IL_0006:  pop
+        IL_0007:  ldarg.0
+        IL_0008:  stloc.1
+        IL_0009:  ldc.i4.0
+        IL_000a:  stloc.0
+        IL_000b:  ldc.i4     0x9e3779b9
+        IL_0010:  ldarg.1
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  ldloc.0
+        IL_0019:  ldc.i4.6
+        IL_001a:  shl
+        IL_001b:  ldloc.0
+        IL_001c:  ldc.i4.2
+        IL_001d:  shr
+        IL_001e:  add
+        IL_001f:  add
+        IL_0020:  add
+        IL_0021:  stloc.0
+        IL_0022:  ldloc.0
+        IL_0023:  ret
+
+        IL_0024:  ldc.i4.0
+        IL_0025:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 XYZ.ABC/ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance bool  Equals(object obj,
+                                    class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class XYZ.ABC/ABC/Expr V_2,
+                 class XYZ.ABC/ABC/Expr V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0029
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     XYZ.ABC/ABC/Expr
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0027
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldarg.0
+        IL_0010:  pop
+        IL_0011:  ldarg.0
+        IL_0012:  stloc.2
+        IL_0013:  ldloc.1
+        IL_0014:  stloc.3
+        IL_0015:  ldarg.2
+        IL_0016:  stloc.s    V_4
+        IL_0018:  ldloc.2
+        IL_0019:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_001e:  ldloc.3
+        IL_001f:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0024:  ceq
+        IL_0026:  ret
+
+        IL_0027:  ldc.i4.0
+        IL_0028:  ret
+
+        IL_0029:  ldarg.1
+        IL_002a:  ldnull
+        IL_002b:  cgt.un
+        IL_002d:  ldc.i4.0
+        IL_002e:  ceq
+        IL_0030:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(class XYZ.ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_001d
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_001b
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldloc.0
+        IL_000d:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  ceq
+        IL_001a:  ret
+
+        IL_001b:  ldc.i4.0
+        IL_001c:  ret
+
+        IL_001d:  ldarg.1
+        IL_001e:  ldnull
+        IL_001f:  cgt.un
+        IL_0021:  ldc.i4.0
+        IL_0022:  ceq
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     XYZ.ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool XYZ.ABC/ABC/Expr::Equals(class XYZ.ABC/ABC/Expr)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Tag()
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/Expr::get_Tag()
+      } 
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/Expr::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit MyExn
+           extends [runtime]System.Exception
+           implements [runtime]System.Collections.IStructuralEquatable
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+      .field assembly int32 Data0@
+      .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 XYZ.ABC/ABC/MyExn::Data0@
+        IL_000d:  ret
+      } 
+
+      .method public specialname rtspecialname instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method family specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  ldarg.2
+        IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                             valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+        IL_0008:  ret
+      } 
+
+      .method public hidebysig specialname instance int32  get_Data0() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 XYZ.ABC/ABC/MyExn::Data0@
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [runtime]System.Collections.IEqualityComparer V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0023
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldc.i4     0x9e3779b9
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldarg.0
+        IL_000d:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0012:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0017:  ldloc.0
+        IL_0018:  ldc.i4.6
+        IL_0019:  shl
+        IL_001a:  ldloc.0
+        IL_001b:  ldc.i4.2
+        IL_001c:  shr
+        IL_001d:  add
+        IL_001e:  add
+        IL_001f:  add
+        IL_0020:  stloc.0
+        IL_0021:  ldloc.0
+        IL_0022:  ret
+
+        IL_0023:  ldc.i4.0
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 XYZ.ABC/ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual instance bool 
+              Equals(object obj,
+                     class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1,
+                 object V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_003b
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     [runtime]System.Exception
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0039
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldloc.0
+        IL_0010:  stloc.2
+        IL_0011:  ldloc.2
+        IL_0012:  isinst     XYZ.ABC/ABC/MyExn
+        IL_0017:  ldnull
+        IL_0018:  cgt.un
+        IL_001a:  brfalse.s  IL_0037
+
+        IL_001c:  ldarg.2
+        IL_001d:  stloc.3
+        IL_001e:  ldarg.0
+        IL_001f:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0024:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ldloc.1
+        IL_002a:  castclass  XYZ.ABC/ABC/MyExn
+        IL_002f:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0034:  ceq
+        IL_0036:  ret
+
+        IL_0037:  ldc.i4.0
+        IL_0038:  ret
+
+        IL_0039:  ldc.i4.0
+        IL_003a:  ret
+
+        IL_003b:  ldarg.1
+        IL_003c:  ldnull
+        IL_003d:  cgt.un
+        IL_003f:  ldc.i4.0
+        IL_0040:  ceq
+        IL_0042:  ret
+      } 
+
+      .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (object V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0030
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002e
+
+        IL_0006:  ldarg.1
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  isinst     XYZ.ABC/ABC/MyExn
+        IL_000e:  ldnull
+        IL_000f:  cgt.un
+        IL_0011:  brfalse.s  IL_002c
+
+        IL_0013:  ldarg.0
+        IL_0014:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0019:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_001e:  ldarg.1
+        IL_001f:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0024:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ceq
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+
+        IL_0030:  ldarg.1
+        IL_0031:  ldnull
+        IL_0032:  cgt.un
+        IL_0034:  ldc.i4.0
+        IL_0035:  ceq
+        IL_0037:  ret
+      } 
+
+      .method public hidebysig virtual instance bool Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     [runtime]System.Exception
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool XYZ.ABC/ABC/MyExn::Equals(class [runtime]System.Exception)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Data0()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+      } 
+    } 
+
+    .class auto ansi serializable nested public A
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+      .field assembly string x
+      .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  ldarg.1
+        IL_000a:  stfld      string XYZ.ABC/ABC/A::x
+        IL_000f:  ret
+      } 
+
+      .method public hidebysig specialname instance string  get_X() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      string XYZ.ABC/ABC/A::x
+        IL_0006:  ret
+      } 
+
+      .property instance string X()
+      {
+        .get instance string XYZ.ABC/ABC/A::get_X()
+      } 
+    } 
+
+    .method public static int32  'add'(int32 x,
+                                       int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public specialname static string get_greeting() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  ret
+    } 
+
+    .property string greeting()
+    {
+      .get string XYZ.ABC/ABC::get_greeting()
+    } 
+  } 
+
+  .method public static int32  'add'(int32 x,
+                                     int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public specialname static string get_greeting() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello"
+    IL_0005:  ret
+  } 
+
+  .property string greeting()
+  {
+    .get string XYZ.ABC::get_greeting()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+.class private auto ansi serializable sealed System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+       extends [runtime]System.Enum
+{
+  .custom instance void [runtime]System.FlagsAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field public specialname rtspecialname int32 value__
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes All = int32(0xFFFFFFFF)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes None = int32(0x00000000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicParameterlessConstructor = int32(0x00000001)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicConstructors = int32(0x00000003)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicConstructors = int32(0x00000004)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicMethods = int32(0x00000008)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicMethods = int32(0x00000010)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicFields = int32(0x00000020)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicFields = int32(0x00000040)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicNestedTypes = int32(0x00000080)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicNestedTypes = int32(0x00000100)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicProperties = int32(0x00000200)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicProperties = int32(0x00000400)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes PublicEvents = int32(0x00000800)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes NonPublicEvents = int32(0x00001000)
+  .field public static literal valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes Interfaces = int32(0x00002000)
+} 
+
+.class private auto ansi beforefieldinit System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute
+       extends [runtime]System.Attribute
+{
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .field private class [runtime]System.Type Type@
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public specialname rtspecialname 
+          instance void  .ctor(valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes MemberType,
+                               class [runtime]System.Type Type) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Attribute::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_000d:  ldarg.0
+    IL_000e:  ldarg.2
+    IL_000f:  stfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0014:  ret
+  } 
+
+  .method public hidebysig specialname instance class [runtime]System.Type get_Type() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::Type@
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig specialname instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes get_MemberType() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::MemberType@
+    IL_0006:  ret
+  } 
+
+  .property instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes
+          MemberType()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance valuetype System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_MemberType()
+  } 
+  .property instance class [runtime]System.Type
+          Type()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance class [runtime]System.Type System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::get_Type()
+  } 
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOn.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOn.il.netcore.debug.bsl
new file mode 100644
index 00000000000..0fe76543a75
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOn.il.netcore.debug.bsl
@@ -0,0 +1,2220 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public auto autochar serializable sealed beforefieldinit XYZ.Expr
+       extends [runtime]System.Object
+       implements class [runtime]System.IEquatable`1<class XYZ.Expr>,
+                  [runtime]System.Collections.IStructuralEquatable,
+                  class [runtime]System.IComparable`1<class XYZ.Expr>,
+                  [runtime]System.IComparable,
+                  [runtime]System.Collections.IStructuralComparable
+{
+  .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                       61 79 28 29 2C 6E 71 7D 00 00 )                   
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+  .field assembly initonly int32 item
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static class XYZ.Expr  NewNum(int32 item) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  newobj     instance void XYZ.Expr::.ctor(int32)
+    IL_0006:  ret
+  } 
+
+  .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+  {
+    .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                            class [runtime]System.Type) = ( 01 00 60 06 00 00 08 58 59 5A 2E 45 78 70 72 00   
+                                                                                                                                                   00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      int32 XYZ.Expr::item
+    IL_000d:  ret
+  } 
+
+  .method public hidebysig instance int32 get_Item() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      int32 XYZ.Expr::item
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig instance int32 get_Tag() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  pop
+    IL_0002:  ldc.i4.0
+    IL_0003:  ret
+  } 
+
+  .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+0.8A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public strict virtual instance string ToString() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.Expr>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  CompareTo(class XYZ.Expr obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class [runtime]System.Collections.IComparer V_2,
+             int32 V_3,
+             int32 V_4,
+             class [runtime]System.Collections.IComparer V_5,
+             int32 V_6,
+             int32 V_7)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_003b
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_0039
+
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  stloc.0
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.0
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.1
+    IL_001a:  ldfld      int32 XYZ.Expr::item
+    IL_001f:  stloc.s    V_4
+    IL_0021:  ldloc.2
+    IL_0022:  stloc.s    V_5
+    IL_0024:  ldloc.3
+    IL_0025:  stloc.s    V_6
+    IL_0027:  ldloc.s    V_4
+    IL_0029:  stloc.s    V_7
+    IL_002b:  ldloc.s    V_6
+    IL_002d:  ldloc.s    V_7
+    IL_002f:  cgt
+    IL_0031:  ldloc.s    V_6
+    IL_0033:  ldloc.s    V_7
+    IL_0035:  clt
+    IL_0037:  sub
+    IL_0038:  ret
+
+    IL_0039:  ldc.i4.1
+    IL_003a:  ret
+
+    IL_003b:  ldarg.1
+    IL_003c:  brfalse.s  IL_0040
+
+    IL_003e:  ldc.i4.m1
+    IL_003f:  ret
+
+    IL_0040:  ldc.i4.0
+    IL_0041:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  unbox.any  XYZ.Expr
+    IL_0007:  callvirt   instance int32 XYZ.Expr::CompareTo(class XYZ.Expr)
+    IL_000c:  ret
+  } 
+
+  .method public hidebysig virtual final 
+          instance int32  CompareTo(object obj,
+                                    class [runtime]System.Collections.IComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class XYZ.Expr V_2,
+             class [runtime]System.Collections.IComparer V_3,
+             int32 V_4,
+             int32 V_5,
+             class [runtime]System.Collections.IComparer V_6,
+             int32 V_7,
+             int32 V_8)
+    IL_0000:  ldarg.1
+    IL_0001:  unbox.any  XYZ.Expr
+    IL_0006:  stloc.0
+    IL_0007:  ldarg.0
+    IL_0008:  brfalse.s  IL_0045
+
+    IL_000a:  ldarg.1
+    IL_000b:  unbox.any  XYZ.Expr
+    IL_0010:  brfalse.s  IL_0043
+
+    IL_0012:  ldarg.0
+    IL_0013:  pop
+    IL_0014:  ldarg.0
+    IL_0015:  stloc.1
+    IL_0016:  ldloc.0
+    IL_0017:  stloc.2
+    IL_0018:  ldarg.2
+    IL_0019:  stloc.3
+    IL_001a:  ldloc.1
+    IL_001b:  ldfld      int32 XYZ.Expr::item
+    IL_0020:  stloc.s    V_4
+    IL_0022:  ldloc.2
+    IL_0023:  ldfld      int32 XYZ.Expr::item
+    IL_0028:  stloc.s    V_5
+    IL_002a:  ldloc.3
+    IL_002b:  stloc.s    V_6
+    IL_002d:  ldloc.s    V_4
+    IL_002f:  stloc.s    V_7
+    IL_0031:  ldloc.s    V_5
+    IL_0033:  stloc.s    V_8
+    IL_0035:  ldloc.s    V_7
+    IL_0037:  ldloc.s    V_8
+    IL_0039:  cgt
+    IL_003b:  ldloc.s    V_7
+    IL_003d:  ldloc.s    V_8
+    IL_003f:  clt
+    IL_0041:  sub
+    IL_0042:  ret
+
+    IL_0043:  ldc.i4.1
+    IL_0044:  ret
+
+    IL_0045:  ldarg.1
+    IL_0046:  unbox.any  XYZ.Expr
+    IL_004b:  brfalse.s  IL_004f
+
+    IL_004d:  ldc.i4.m1
+    IL_004e:  ret
+
+    IL_004f:  ldc.i4.0
+    IL_0050:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             class XYZ.Expr V_1,
+             class [runtime]System.Collections.IEqualityComparer V_2,
+             int32 V_3,
+             class [runtime]System.Collections.IEqualityComparer V_4)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0029
+
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.0
+    IL_0005:  ldarg.0
+    IL_0006:  pop
+    IL_0007:  ldarg.0
+    IL_0008:  stloc.1
+    IL_0009:  ldc.i4.0
+    IL_000a:  stloc.0
+    IL_000b:  ldc.i4     0x9e3779b9
+    IL_0010:  ldarg.1
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.1
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.2
+    IL_001a:  stloc.s    V_4
+    IL_001c:  ldloc.3
+    IL_001d:  ldloc.0
+    IL_001e:  ldc.i4.6
+    IL_001f:  shl
+    IL_0020:  ldloc.0
+    IL_0021:  ldc.i4.2
+    IL_0022:  shr
+    IL_0023:  add
+    IL_0024:  add
+    IL_0025:  add
+    IL_0026:  stloc.0
+    IL_0027:  ldloc.0
+    IL_0028:  ret
+
+    IL_0029:  ldc.i4.0
+    IL_002a:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0006:  callvirt   instance int32 XYZ.Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+    IL_000b:  ret
+  } 
+
+  .method public hidebysig virtual final 
+          instance bool  Equals(object obj,
+                                class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class XYZ.Expr V_2,
+             class XYZ.Expr V_3,
+             class [runtime]System.Collections.IEqualityComparer V_4,
+             int32 V_5,
+             int32 V_6,
+             class [runtime]System.Collections.IEqualityComparer V_7)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0035
+
+    IL_0003:  ldarg.1
+    IL_0004:  isinst     XYZ.Expr
+    IL_0009:  stloc.0
+    IL_000a:  ldloc.0
+    IL_000b:  brfalse.s  IL_0033
+
+    IL_000d:  ldloc.0
+    IL_000e:  stloc.1
+    IL_000f:  ldarg.0
+    IL_0010:  pop
+    IL_0011:  ldarg.0
+    IL_0012:  stloc.2
+    IL_0013:  ldloc.1
+    IL_0014:  stloc.3
+    IL_0015:  ldarg.2
+    IL_0016:  stloc.s    V_4
+    IL_0018:  ldloc.2
+    IL_0019:  ldfld      int32 XYZ.Expr::item
+    IL_001e:  stloc.s    V_5
+    IL_0020:  ldloc.3
+    IL_0021:  ldfld      int32 XYZ.Expr::item
+    IL_0026:  stloc.s    V_6
+    IL_0028:  ldloc.s    V_4
+    IL_002a:  stloc.s    V_7
+    IL_002c:  ldloc.s    V_5
+    IL_002e:  ldloc.s    V_6
+    IL_0030:  ceq
+    IL_0032:  ret
+
+    IL_0033:  ldc.i4.0
+    IL_0034:  ret
+
+    IL_0035:  ldarg.1
+    IL_0036:  ldnull
+    IL_0037:  cgt.un
+    IL_0039:  ldc.i4.0
+    IL_003a:  ceq
+    IL_003c:  ret
+  } 
+
+  .method public hidebysig virtual final instance bool  Equals(class XYZ.Expr obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_001d
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_001b
+
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  stloc.0
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  ldloc.0
+    IL_000d:  ldfld      int32 XYZ.Expr::item
+    IL_0012:  ldloc.1
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  ceq
+    IL_001a:  ret
+
+    IL_001b:  ldc.i4.0
+    IL_001c:  ret
+
+    IL_001d:  ldarg.1
+    IL_001e:  ldnull
+    IL_001f:  cgt.un
+    IL_0021:  ldc.i4.0
+    IL_0022:  ceq
+    IL_0024:  ret
+  } 
+
+  .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  isinst     XYZ.Expr
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_0012
+
+    IL_000a:  ldarg.0
+    IL_000b:  ldloc.0
+    IL_000c:  callvirt   instance bool XYZ.Expr::Equals(class XYZ.Expr)
+    IL_0011:  ret
+
+    IL_0012:  ldc.i4.0
+    IL_0013:  ret
+  } 
+
+  .property instance int32 Tag()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .get instance int32 XYZ.Expr::get_Tag()
+  } 
+  .property instance int32 Item()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32,
+                                                                                                int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance int32 XYZ.Expr::get_Item()
+  } 
+} 
+
+.class public auto ansi serializable beforefieldinit XYZ.MyExn
+       extends [runtime]System.Exception
+       implements [runtime]System.Collections.IStructuralEquatable
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+  .field assembly int32 Data0@
+  .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      int32 XYZ.MyExn::Data0@
+    IL_000d:  ret
+  } 
+
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+    IL_0006:  ret
+  } 
+
+  .method family specialname rtspecialname 
+          instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                               valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  ldarg.2
+    IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                               valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+    IL_0008:  ret
+  } 
+
+  .method public hidebysig specialname instance int32 get_Data0() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      int32 XYZ.MyExn::Data0@
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             class [runtime]System.Collections.IEqualityComparer V_1,
+             int32 V_2,
+             class [runtime]System.Collections.IEqualityComparer V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0027
+
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.0
+    IL_0005:  ldc.i4     0x9e3779b9
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  ldarg.0
+    IL_000d:  castclass  XYZ.MyExn
+    IL_0012:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0017:  stloc.2
+    IL_0018:  ldloc.1
+    IL_0019:  stloc.3
+    IL_001a:  ldloc.2
+    IL_001b:  ldloc.0
+    IL_001c:  ldc.i4.6
+    IL_001d:  shl
+    IL_001e:  ldloc.0
+    IL_001f:  ldc.i4.2
+    IL_0020:  shr
+    IL_0021:  add
+    IL_0022:  add
+    IL_0023:  add
+    IL_0024:  stloc.0
+    IL_0025:  ldloc.0
+    IL_0026:  ret
+
+    IL_0027:  ldc.i4.0
+    IL_0028:  ret
+  } 
+
+  .method public hidebysig virtual instance int32 GetHashCode() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0006:  callvirt   instance int32 XYZ.MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+    IL_000b:  ret
+  } 
+
+  .method public hidebysig virtual instance bool 
+          Equals(object obj,
+                 class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0,
+             class [runtime]System.Exception V_1,
+             object V_2,
+             class [runtime]System.Collections.IEqualityComparer V_3,
+             int32 V_4,
+             int32 V_5,
+             class [runtime]System.Collections.IEqualityComparer V_6)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0046
+
+    IL_0003:  ldarg.1
+    IL_0004:  isinst     [runtime]System.Exception
+    IL_0009:  stloc.0
+    IL_000a:  ldloc.0
+    IL_000b:  brfalse.s  IL_0044
+
+    IL_000d:  ldloc.0
+    IL_000e:  stloc.1
+    IL_000f:  ldloc.0
+    IL_0010:  stloc.2
+    IL_0011:  ldloc.2
+    IL_0012:  isinst     XYZ.MyExn
+    IL_0017:  ldnull
+    IL_0018:  cgt.un
+    IL_001a:  brfalse.s  IL_0042
+
+    IL_001c:  ldarg.2
+    IL_001d:  stloc.3
+    IL_001e:  ldarg.0
+    IL_001f:  castclass  XYZ.MyExn
+    IL_0024:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0029:  stloc.s    V_4
+    IL_002b:  ldloc.1
+    IL_002c:  castclass  XYZ.MyExn
+    IL_0031:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0036:  stloc.s    V_5
+    IL_0038:  ldloc.3
+    IL_0039:  stloc.s    V_6
+    IL_003b:  ldloc.s    V_4
+    IL_003d:  ldloc.s    V_5
+    IL_003f:  ceq
+    IL_0041:  ret
+
+    IL_0042:  ldc.i4.0
+    IL_0043:  ret
+
+    IL_0044:  ldc.i4.0
+    IL_0045:  ret
+
+    IL_0046:  ldarg.1
+    IL_0047:  ldnull
+    IL_0048:  cgt.un
+    IL_004a:  ldc.i4.0
+    IL_004b:  ceq
+    IL_004d:  ret
+  } 
+
+  .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (object V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0030
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_002e
+
+    IL_0006:  ldarg.1
+    IL_0007:  stloc.0
+    IL_0008:  ldloc.0
+    IL_0009:  isinst     XYZ.MyExn
+    IL_000e:  ldnull
+    IL_000f:  cgt.un
+    IL_0011:  brfalse.s  IL_002c
+
+    IL_0013:  ldarg.0
+    IL_0014:  castclass  XYZ.MyExn
+    IL_0019:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_001e:  ldarg.1
+    IL_001f:  castclass  XYZ.MyExn
+    IL_0024:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0029:  ceq
+    IL_002b:  ret
+
+    IL_002c:  ldc.i4.0
+    IL_002d:  ret
+
+    IL_002e:  ldc.i4.0
+    IL_002f:  ret
+
+    IL_0030:  ldarg.1
+    IL_0031:  ldnull
+    IL_0032:  cgt.un
+    IL_0034:  ldc.i4.0
+    IL_0035:  ceq
+    IL_0037:  ret
+  } 
+
+  .method public hidebysig virtual instance bool Equals(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  isinst     [runtime]System.Exception
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_0012
+
+    IL_000a:  ldarg.0
+    IL_000b:  ldloc.0
+    IL_000c:  callvirt   instance bool XYZ.MyExn::Equals(class [runtime]System.Exception)
+    IL_0011:  ret
+
+    IL_0012:  ldc.i4.0
+    IL_0013:  ret
+  } 
+
+  .property instance int32 Data0()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+    .get instance int32 XYZ.MyExn::get_Data0()
+  } 
+} 
+
+.class public auto ansi serializable XYZ.A
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .field assembly string x
+  .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  ldarg.1
+    IL_000a:  stfld      string XYZ.A::x
+    IL_000f:  ret
+  } 
+
+  .method public hidebysig specialname instance string get_X() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      string XYZ.A::x
+    IL_0006:  ret
+  } 
+
+  .property instance string X()
+  {
+    .get instance string XYZ.A::get_X()
+  } 
+} 
+
+.class public abstract auto ansi sealed XYZ.ABC
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Expr
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class XYZ.ABC/Expr>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class XYZ.ABC/Expr>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                         61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field assembly initonly int32 item
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public static class XYZ.ABC/Expr NewNum(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void XYZ.ABC/Expr::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+    {
+      .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                              class [runtime]System.Type) = ( 01 00 60 06 00 00 0C 58 59 5A 2E 41 42 43 2B 45   
+                                                                                                                                                     78 70 72 00 00 )                                  
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 XYZ.ABC/Expr::item
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Item() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/Expr>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class XYZ.ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4,
+               class [runtime]System.Collections.IComparer V_5,
+               int32 V_6,
+               int32 V_7)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_003b
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_0039
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.0
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.1
+      IL_001a:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.2
+      IL_0022:  stloc.s    V_5
+      IL_0024:  ldloc.3
+      IL_0025:  stloc.s    V_6
+      IL_0027:  ldloc.s    V_4
+      IL_0029:  stloc.s    V_7
+      IL_002b:  ldloc.s    V_6
+      IL_002d:  ldloc.s    V_7
+      IL_002f:  cgt
+      IL_0031:  ldloc.s    V_6
+      IL_0033:  ldloc.s    V_7
+      IL_0035:  clt
+      IL_0037:  sub
+      IL_0038:  ret
+
+      IL_0039:  ldc.i4.1
+      IL_003a:  ret
+
+      IL_003b:  ldarg.1
+      IL_003c:  brfalse.s  IL_0040
+
+      IL_003e:  ldc.i4.m1
+      IL_003f:  ret
+
+      IL_0040:  ldc.i4.0
+      IL_0041:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  XYZ.ABC/Expr
+      IL_0007:  callvirt   instance int32 XYZ.ABC/Expr::CompareTo(class XYZ.ABC/Expr)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class XYZ.ABC/Expr V_2,
+               class [runtime]System.Collections.IComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IComparer V_6,
+               int32 V_7,
+               int32 V_8)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  XYZ.ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_0045
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  XYZ.ABC/Expr
+      IL_0010:  brfalse.s  IL_0043
+
+      IL_0012:  ldarg.0
+      IL_0013:  pop
+      IL_0014:  ldarg.0
+      IL_0015:  stloc.1
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  ldarg.2
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.1
+      IL_001b:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0020:  stloc.s    V_4
+      IL_0022:  ldloc.2
+      IL_0023:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0028:  stloc.s    V_5
+      IL_002a:  ldloc.3
+      IL_002b:  stloc.s    V_6
+      IL_002d:  ldloc.s    V_4
+      IL_002f:  stloc.s    V_7
+      IL_0031:  ldloc.s    V_5
+      IL_0033:  stloc.s    V_8
+      IL_0035:  ldloc.s    V_7
+      IL_0037:  ldloc.s    V_8
+      IL_0039:  cgt
+      IL_003b:  ldloc.s    V_7
+      IL_003d:  ldloc.s    V_8
+      IL_003f:  clt
+      IL_0041:  sub
+      IL_0042:  ret
+
+      IL_0043:  ldc.i4.1
+      IL_0044:  ret
+
+      IL_0045:  ldarg.1
+      IL_0046:  unbox.any  XYZ.ABC/Expr
+      IL_004b:  brfalse.s  IL_004f
+
+      IL_004d:  ldc.i4.m1
+      IL_004e:  ret
+
+      IL_004f:  ldc.i4.0
+      IL_0050:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class XYZ.ABC/Expr V_1,
+               class [runtime]System.Collections.IEqualityComparer V_2,
+               int32 V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0029
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldarg.0
+      IL_0008:  stloc.1
+      IL_0009:  ldc.i4.0
+      IL_000a:  stloc.0
+      IL_000b:  ldc.i4     0x9e3779b9
+      IL_0010:  ldarg.1
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.2
+      IL_001a:  stloc.s    V_4
+      IL_001c:  ldloc.3
+      IL_001d:  ldloc.0
+      IL_001e:  ldc.i4.6
+      IL_001f:  shl
+      IL_0020:  ldloc.0
+      IL_0021:  ldc.i4.2
+      IL_0022:  shr
+      IL_0023:  add
+      IL_0024:  add
+      IL_0025:  add
+      IL_0026:  stloc.0
+      IL_0027:  ldloc.0
+      IL_0028:  ret
+
+      IL_0029:  ldc.i4.0
+      IL_002a:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 XYZ.ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class XYZ.ABC/Expr V_2,
+               class XYZ.ABC/Expr V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4,
+               int32 V_5,
+               int32 V_6,
+               class [runtime]System.Collections.IEqualityComparer V_7)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0035
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     XYZ.ABC/Expr
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0033
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  pop
+      IL_0011:  ldarg.0
+      IL_0012:  stloc.2
+      IL_0013:  ldloc.1
+      IL_0014:  stloc.3
+      IL_0015:  ldarg.2
+      IL_0016:  stloc.s    V_4
+      IL_0018:  ldloc.2
+      IL_0019:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_001e:  stloc.s    V_5
+      IL_0020:  ldloc.3
+      IL_0021:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0026:  stloc.s    V_6
+      IL_0028:  ldloc.s    V_4
+      IL_002a:  stloc.s    V_7
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  ldloc.s    V_6
+      IL_0030:  ceq
+      IL_0032:  ret
+
+      IL_0033:  ldc.i4.0
+      IL_0034:  ret
+
+      IL_0035:  ldarg.1
+      IL_0036:  ldnull
+      IL_0037:  cgt.un
+      IL_0039:  ldc.i4.0
+      IL_003a:  ceq
+      IL_003c:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class XYZ.ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001d
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001b
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldloc.0
+      IL_000d:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  ceq
+      IL_001a:  ret
+
+      IL_001b:  ldc.i4.0
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  ldnull
+      IL_001f:  cgt.un
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     XYZ.ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool XYZ.ABC/Expr::Equals(class XYZ.ABC/Expr)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 XYZ.ABC/Expr::get_Tag()
+    } 
+    .property instance int32 Item()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .get instance int32 XYZ.ABC/Expr::get_Item()
+    } 
+  } 
+
+  .class auto ansi serializable nested public beforefieldinit MyExn
+         extends [runtime]System.Exception
+         implements [runtime]System.Collections.IStructuralEquatable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+    .field assembly int32 Data0@
+    .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 XYZ.ABC/MyExn::Data0@
+      IL_000d:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method family specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  ldarg.2
+      IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_Data0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 XYZ.ABC/MyExn::Data0@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1,
+               int32 V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0027
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldc.i4     0x9e3779b9
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  castclass  XYZ.ABC/MyExn
+      IL_0012:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0017:  stloc.2
+      IL_0018:  ldloc.1
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.2
+      IL_001b:  ldloc.0
+      IL_001c:  ldc.i4.6
+      IL_001d:  shl
+      IL_001e:  ldloc.0
+      IL_001f:  ldc.i4.2
+      IL_0020:  shr
+      IL_0021:  add
+      IL_0022:  add
+      IL_0023:  add
+      IL_0024:  stloc.0
+      IL_0025:  ldloc.0
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 XYZ.ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual instance bool 
+            Equals(object obj,
+                   class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1,
+               object V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3,
+               int32 V_4,
+               int32 V_5,
+               class [runtime]System.Collections.IEqualityComparer V_6)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0046
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     [runtime]System.Exception
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0044
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldloc.0
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.2
+      IL_0012:  isinst     XYZ.ABC/MyExn
+      IL_0017:  ldnull
+      IL_0018:  cgt.un
+      IL_001a:  brfalse.s  IL_0042
+
+      IL_001c:  ldarg.2
+      IL_001d:  stloc.3
+      IL_001e:  ldarg.0
+      IL_001f:  castclass  XYZ.ABC/MyExn
+      IL_0024:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0029:  stloc.s    V_4
+      IL_002b:  ldloc.1
+      IL_002c:  castclass  XYZ.ABC/MyExn
+      IL_0031:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0036:  stloc.s    V_5
+      IL_0038:  ldloc.3
+      IL_0039:  stloc.s    V_6
+      IL_003b:  ldloc.s    V_4
+      IL_003d:  ldloc.s    V_5
+      IL_003f:  ceq
+      IL_0041:  ret
+
+      IL_0042:  ldc.i4.0
+      IL_0043:  ret
+
+      IL_0044:  ldc.i4.0
+      IL_0045:  ret
+
+      IL_0046:  ldarg.1
+      IL_0047:  ldnull
+      IL_0048:  cgt.un
+      IL_004a:  ldc.i4.0
+      IL_004b:  ceq
+      IL_004d:  ret
+    } 
+
+    .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0030
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002e
+
+      IL_0006:  ldarg.1
+      IL_0007:  stloc.0
+      IL_0008:  ldloc.0
+      IL_0009:  isinst     XYZ.ABC/MyExn
+      IL_000e:  ldnull
+      IL_000f:  cgt.un
+      IL_0011:  brfalse.s  IL_002c
+
+      IL_0013:  ldarg.0
+      IL_0014:  castclass  XYZ.ABC/MyExn
+      IL_0019:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_001e:  ldarg.1
+      IL_001f:  castclass  XYZ.ABC/MyExn
+      IL_0024:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0029:  ceq
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+
+      IL_0030:  ldarg.1
+      IL_0031:  ldnull
+      IL_0032:  cgt.un
+      IL_0034:  ldc.i4.0
+      IL_0035:  ceq
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual instance bool Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     [runtime]System.Exception
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool XYZ.ABC/MyExn::Equals(class [runtime]System.Exception)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Data0()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance int32 XYZ.ABC/MyExn::get_Data0()
+    } 
+  } 
+
+  .class auto ansi serializable nested public A
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly string x
+    .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldarg.1
+      IL_000a:  stfld      string XYZ.ABC/A::x
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance string  get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string XYZ.ABC/A::x
+      IL_0006:  ret
+    } 
+
+    .property instance string X()
+    {
+      .get instance string XYZ.ABC/A::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public ABC
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested public beforefieldinit Expr
+           extends [runtime]System.Object
+           implements class [runtime]System.IEquatable`1<class XYZ.ABC/ABC/Expr>,
+                      [runtime]System.Collections.IStructuralEquatable,
+                      class [runtime]System.IComparable`1<class XYZ.ABC/ABC/Expr>,
+                      [runtime]System.IComparable,
+                      [runtime]System.Collections.IStructuralComparable
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                           61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public static class XYZ.ABC/ABC/Expr NewNum(int32 item) cil managed
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void XYZ.ABC/ABC/Expr::.ctor(int32)
+        IL_0006:  ret
+      } 
+
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 10 58 59 5A 2E 41 42 43 2B 41   
+                                                                                                                                                       42 43 2B 45 78 70 72 00 00 )                      
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Tag() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  pop
+        IL_0002:  ldc.i4.0
+        IL_0003:  ret
+      } 
+
+      .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+0.8A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public strict virtual instance string ToString() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/ABC/Expr>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(class XYZ.ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IComparer V_2,
+                 int32 V_3,
+                 int32 V_4,
+                 class [runtime]System.Collections.IComparer V_5,
+                 int32 V_6,
+                 int32 V_7)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_003b
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_0039
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.0
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.1
+        IL_001a:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_001f:  stloc.s    V_4
+        IL_0021:  ldloc.2
+        IL_0022:  stloc.s    V_5
+        IL_0024:  ldloc.3
+        IL_0025:  stloc.s    V_6
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  stloc.s    V_7
+        IL_002b:  ldloc.s    V_6
+        IL_002d:  ldloc.s    V_7
+        IL_002f:  cgt
+        IL_0031:  ldloc.s    V_6
+        IL_0033:  ldloc.s    V_7
+        IL_0035:  clt
+        IL_0037:  sub
+        IL_0038:  ret
+
+        IL_0039:  ldc.i4.1
+        IL_003a:  ret
+
+        IL_003b:  ldarg.1
+        IL_003c:  brfalse.s  IL_0040
+
+        IL_003e:  ldc.i4.m1
+        IL_003f:  ret
+
+        IL_0040:  ldc.i4.0
+        IL_0041:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0007:  callvirt   instance int32 XYZ.ABC/ABC/Expr::CompareTo(class XYZ.ABC/ABC/Expr)
+        IL_000c:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance int32  CompareTo(object obj,
+                                        class [runtime]System.Collections.IComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class XYZ.ABC/ABC/Expr V_2,
+                 class [runtime]System.Collections.IComparer V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class [runtime]System.Collections.IComparer V_6,
+                 int32 V_7,
+                 int32 V_8)
+        IL_0000:  ldarg.1
+        IL_0001:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  brfalse.s  IL_0045
+
+        IL_000a:  ldarg.1
+        IL_000b:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0010:  brfalse.s  IL_0043
+
+        IL_0012:  ldarg.0
+        IL_0013:  pop
+        IL_0014:  ldarg.0
+        IL_0015:  stloc.1
+        IL_0016:  ldloc.0
+        IL_0017:  stloc.2
+        IL_0018:  ldarg.2
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.1
+        IL_001b:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0020:  stloc.s    V_4
+        IL_0022:  ldloc.2
+        IL_0023:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0028:  stloc.s    V_5
+        IL_002a:  ldloc.3
+        IL_002b:  stloc.s    V_6
+        IL_002d:  ldloc.s    V_4
+        IL_002f:  stloc.s    V_7
+        IL_0031:  ldloc.s    V_5
+        IL_0033:  stloc.s    V_8
+        IL_0035:  ldloc.s    V_7
+        IL_0037:  ldloc.s    V_8
+        IL_0039:  cgt
+        IL_003b:  ldloc.s    V_7
+        IL_003d:  ldloc.s    V_8
+        IL_003f:  clt
+        IL_0041:  sub
+        IL_0042:  ret
+
+        IL_0043:  ldc.i4.1
+        IL_0044:  ret
+
+        IL_0045:  ldarg.1
+        IL_0046:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_004b:  brfalse.s  IL_004f
+
+        IL_004d:  ldc.i4.m1
+        IL_004e:  ret
+
+        IL_004f:  ldc.i4.0
+        IL_0050:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IEqualityComparer V_2,
+                 int32 V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0029
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldarg.0
+        IL_0006:  pop
+        IL_0007:  ldarg.0
+        IL_0008:  stloc.1
+        IL_0009:  ldc.i4.0
+        IL_000a:  stloc.0
+        IL_000b:  ldc.i4     0x9e3779b9
+        IL_0010:  ldarg.1
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.2
+        IL_001a:  stloc.s    V_4
+        IL_001c:  ldloc.3
+        IL_001d:  ldloc.0
+        IL_001e:  ldc.i4.6
+        IL_001f:  shl
+        IL_0020:  ldloc.0
+        IL_0021:  ldc.i4.2
+        IL_0022:  shr
+        IL_0023:  add
+        IL_0024:  add
+        IL_0025:  add
+        IL_0026:  stloc.0
+        IL_0027:  ldloc.0
+        IL_0028:  ret
+
+        IL_0029:  ldc.i4.0
+        IL_002a:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 XYZ.ABC/ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance bool  Equals(object obj,
+                                    class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class XYZ.ABC/ABC/Expr V_2,
+                 class XYZ.ABC/ABC/Expr V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4,
+                 int32 V_5,
+                 int32 V_6,
+                 class [runtime]System.Collections.IEqualityComparer V_7)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0035
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     XYZ.ABC/ABC/Expr
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0033
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldarg.0
+        IL_0010:  pop
+        IL_0011:  ldarg.0
+        IL_0012:  stloc.2
+        IL_0013:  ldloc.1
+        IL_0014:  stloc.3
+        IL_0015:  ldarg.2
+        IL_0016:  stloc.s    V_4
+        IL_0018:  ldloc.2
+        IL_0019:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_001e:  stloc.s    V_5
+        IL_0020:  ldloc.3
+        IL_0021:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0026:  stloc.s    V_6
+        IL_0028:  ldloc.s    V_4
+        IL_002a:  stloc.s    V_7
+        IL_002c:  ldloc.s    V_5
+        IL_002e:  ldloc.s    V_6
+        IL_0030:  ceq
+        IL_0032:  ret
+
+        IL_0033:  ldc.i4.0
+        IL_0034:  ret
+
+        IL_0035:  ldarg.1
+        IL_0036:  ldnull
+        IL_0037:  cgt.un
+        IL_0039:  ldc.i4.0
+        IL_003a:  ceq
+        IL_003c:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(class XYZ.ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_001d
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_001b
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldloc.0
+        IL_000d:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  ceq
+        IL_001a:  ret
+
+        IL_001b:  ldc.i4.0
+        IL_001c:  ret
+
+        IL_001d:  ldarg.1
+        IL_001e:  ldnull
+        IL_001f:  cgt.un
+        IL_0021:  ldc.i4.0
+        IL_0022:  ceq
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     XYZ.ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool XYZ.ABC/ABC/Expr::Equals(class XYZ.ABC/ABC/Expr)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Tag()
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/Expr::get_Tag()
+      } 
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/Expr::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit MyExn
+           extends [runtime]System.Exception
+           implements [runtime]System.Collections.IStructuralEquatable
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+      .field assembly int32 Data0@
+      .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 XYZ.ABC/ABC/MyExn::Data0@
+        IL_000d:  ret
+      } 
+
+      .method public specialname rtspecialname instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method family specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  ldarg.2
+        IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+        IL_0008:  ret
+      } 
+
+      .method public hidebysig specialname instance int32  get_Data0() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 XYZ.ABC/ABC/MyExn::Data0@
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [runtime]System.Collections.IEqualityComparer V_1,
+                 int32 V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0027
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldc.i4     0x9e3779b9
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldarg.0
+        IL_000d:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0012:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0017:  stloc.2
+        IL_0018:  ldloc.1
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.2
+        IL_001b:  ldloc.0
+        IL_001c:  ldc.i4.6
+        IL_001d:  shl
+        IL_001e:  ldloc.0
+        IL_001f:  ldc.i4.2
+        IL_0020:  shr
+        IL_0021:  add
+        IL_0022:  add
+        IL_0023:  add
+        IL_0024:  stloc.0
+        IL_0025:  ldloc.0
+        IL_0026:  ret
+
+        IL_0027:  ldc.i4.0
+        IL_0028:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 XYZ.ABC/ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual instance bool 
+              Equals(object obj,
+                     class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1,
+                 object V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3,
+                 int32 V_4,
+                 int32 V_5,
+                 class [runtime]System.Collections.IEqualityComparer V_6)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0046
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     [runtime]System.Exception
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0044
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldloc.0
+        IL_0010:  stloc.2
+        IL_0011:  ldloc.2
+        IL_0012:  isinst     XYZ.ABC/ABC/MyExn
+        IL_0017:  ldnull
+        IL_0018:  cgt.un
+        IL_001a:  brfalse.s  IL_0042
+
+        IL_001c:  ldarg.2
+        IL_001d:  stloc.3
+        IL_001e:  ldarg.0
+        IL_001f:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0024:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0029:  stloc.s    V_4
+        IL_002b:  ldloc.1
+        IL_002c:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0031:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0036:  stloc.s    V_5
+        IL_0038:  ldloc.3
+        IL_0039:  stloc.s    V_6
+        IL_003b:  ldloc.s    V_4
+        IL_003d:  ldloc.s    V_5
+        IL_003f:  ceq
+        IL_0041:  ret
+
+        IL_0042:  ldc.i4.0
+        IL_0043:  ret
+
+        IL_0044:  ldc.i4.0
+        IL_0045:  ret
+
+        IL_0046:  ldarg.1
+        IL_0047:  ldnull
+        IL_0048:  cgt.un
+        IL_004a:  ldc.i4.0
+        IL_004b:  ceq
+        IL_004d:  ret
+      } 
+
+      .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (object V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0030
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002e
+
+        IL_0006:  ldarg.1
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  isinst     XYZ.ABC/ABC/MyExn
+        IL_000e:  ldnull
+        IL_000f:  cgt.un
+        IL_0011:  brfalse.s  IL_002c
+
+        IL_0013:  ldarg.0
+        IL_0014:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0019:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_001e:  ldarg.1
+        IL_001f:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0024:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ceq
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+
+        IL_0030:  ldarg.1
+        IL_0031:  ldnull
+        IL_0032:  cgt.un
+        IL_0034:  ldc.i4.0
+        IL_0035:  ceq
+        IL_0037:  ret
+      } 
+
+      .method public hidebysig virtual instance bool Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     [runtime]System.Exception
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool XYZ.ABC/ABC/MyExn::Equals(class [runtime]System.Exception)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Data0()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+      } 
+    } 
+
+    .class auto ansi serializable nested public A
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+      .field assembly string x
+      .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  ldarg.1
+        IL_000a:  stfld      string XYZ.ABC/ABC/A::x
+        IL_000f:  ret
+      } 
+
+      .method public hidebysig specialname instance string  get_X() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      string XYZ.ABC/ABC/A::x
+        IL_0006:  ret
+      } 
+
+      .property instance string X()
+      {
+        .get instance string XYZ.ABC/ABC/A::get_X()
+      } 
+    } 
+
+    .method public static int32  'add'(int32 x,
+                                       int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public specialname static string get_greeting() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  ret
+    } 
+
+    .property string greeting()
+    {
+      .get string XYZ.ABC/ABC::get_greeting()
+    } 
+  } 
+
+  .method public static int32  'add'(int32 x,
+                                     int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public specialname static string get_greeting() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello"
+    IL_0005:  ret
+  } 
+
+  .property string greeting()
+  {
+    .get string XYZ.ABC::get_greeting()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOn.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOn.il.netcore.release.bsl
new file mode 100644
index 00000000000..34f7be115da
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/SerializableAttribute/ToplevelNamespace60.fs.RealInternalSignatureOn.il.netcore.release.bsl
@@ -0,0 +1,2076 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public auto autochar serializable sealed beforefieldinit XYZ.Expr
+       extends [runtime]System.Object
+       implements class [runtime]System.IEquatable`1<class XYZ.Expr>,
+                  [runtime]System.Collections.IStructuralEquatable,
+                  class [runtime]System.IComparable`1<class XYZ.Expr>,
+                  [runtime]System.IComparable,
+                  [runtime]System.Collections.IStructuralComparable
+{
+  .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                       61 79 28 29 2C 6E 71 7D 00 00 )                   
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+  .field assembly initonly int32 item
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static class XYZ.Expr  NewNum(int32 item) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  newobj     instance void XYZ.Expr::.ctor(int32)
+    IL_0006:  ret
+  } 
+
+  .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+  {
+    .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                            class [runtime]System.Type) = ( 01 00 60 06 00 00 08 58 59 5A 2E 45 78 70 72 00   
+                                                                                                                                                   00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      int32 XYZ.Expr::item
+    IL_000d:  ret
+  } 
+
+  .method public hidebysig instance int32 get_Item() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      int32 XYZ.Expr::item
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig instance int32 get_Tag() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  pop
+    IL_0002:  ldc.i4.0
+    IL_0003:  ret
+  } 
+
+  .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+0.8A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public strict virtual instance string ToString() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "%+A"
+    IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.Expr>::.ctor(string)
+    IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+    IL_000f:  ldarg.0
+    IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.Expr,string>::Invoke(!0)
+    IL_0015:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  CompareTo(class XYZ.Expr obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class [runtime]System.Collections.IComparer V_2,
+             int32 V_3,
+             int32 V_4)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_002f
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_002d
+
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  stloc.0
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.0
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  stloc.3
+    IL_0019:  ldloc.1
+    IL_001a:  ldfld      int32 XYZ.Expr::item
+    IL_001f:  stloc.s    V_4
+    IL_0021:  ldloc.3
+    IL_0022:  ldloc.s    V_4
+    IL_0024:  cgt
+    IL_0026:  ldloc.3
+    IL_0027:  ldloc.s    V_4
+    IL_0029:  clt
+    IL_002b:  sub
+    IL_002c:  ret
+
+    IL_002d:  ldc.i4.1
+    IL_002e:  ret
+
+    IL_002f:  ldarg.1
+    IL_0030:  brfalse.s  IL_0034
+
+    IL_0032:  ldc.i4.m1
+    IL_0033:  ret
+
+    IL_0034:  ldc.i4.0
+    IL_0035:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  unbox.any  XYZ.Expr
+    IL_0007:  callvirt   instance int32 XYZ.Expr::CompareTo(class XYZ.Expr)
+    IL_000c:  ret
+  } 
+
+  .method public hidebysig virtual final 
+          instance int32  CompareTo(object obj,
+                                    class [runtime]System.Collections.IComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  5
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class XYZ.Expr V_2,
+             class [runtime]System.Collections.IComparer V_3,
+             int32 V_4,
+             int32 V_5)
+    IL_0000:  ldarg.1
+    IL_0001:  unbox.any  XYZ.Expr
+    IL_0006:  stloc.0
+    IL_0007:  ldarg.0
+    IL_0008:  brfalse.s  IL_003a
+
+    IL_000a:  ldarg.1
+    IL_000b:  unbox.any  XYZ.Expr
+    IL_0010:  brfalse.s  IL_0038
+
+    IL_0012:  ldarg.0
+    IL_0013:  pop
+    IL_0014:  ldarg.0
+    IL_0015:  stloc.1
+    IL_0016:  ldloc.0
+    IL_0017:  stloc.2
+    IL_0018:  ldarg.2
+    IL_0019:  stloc.3
+    IL_001a:  ldloc.1
+    IL_001b:  ldfld      int32 XYZ.Expr::item
+    IL_0020:  stloc.s    V_4
+    IL_0022:  ldloc.2
+    IL_0023:  ldfld      int32 XYZ.Expr::item
+    IL_0028:  stloc.s    V_5
+    IL_002a:  ldloc.s    V_4
+    IL_002c:  ldloc.s    V_5
+    IL_002e:  cgt
+    IL_0030:  ldloc.s    V_4
+    IL_0032:  ldloc.s    V_5
+    IL_0034:  clt
+    IL_0036:  sub
+    IL_0037:  ret
+
+    IL_0038:  ldc.i4.1
+    IL_0039:  ret
+
+    IL_003a:  ldarg.1
+    IL_003b:  unbox.any  XYZ.Expr
+    IL_0040:  brfalse.s  IL_0044
+
+    IL_0042:  ldc.i4.m1
+    IL_0043:  ret
+
+    IL_0044:  ldc.i4.0
+    IL_0045:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             class XYZ.Expr V_1,
+             class [runtime]System.Collections.IEqualityComparer V_2)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0024
+
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.0
+    IL_0005:  ldarg.0
+    IL_0006:  pop
+    IL_0007:  ldarg.0
+    IL_0008:  stloc.1
+    IL_0009:  ldc.i4.0
+    IL_000a:  stloc.0
+    IL_000b:  ldc.i4     0x9e3779b9
+    IL_0010:  ldarg.1
+    IL_0011:  stloc.2
+    IL_0012:  ldloc.1
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  ldloc.0
+    IL_0019:  ldc.i4.6
+    IL_001a:  shl
+    IL_001b:  ldloc.0
+    IL_001c:  ldc.i4.2
+    IL_001d:  shr
+    IL_001e:  add
+    IL_001f:  add
+    IL_0020:  add
+    IL_0021:  stloc.0
+    IL_0022:  ldloc.0
+    IL_0023:  ret
+
+    IL_0024:  ldc.i4.0
+    IL_0025:  ret
+  } 
+
+  .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0006:  callvirt   instance int32 XYZ.Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+    IL_000b:  ret
+  } 
+
+  .method public hidebysig virtual final 
+          instance bool  Equals(object obj,
+                                class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1,
+             class XYZ.Expr V_2,
+             class XYZ.Expr V_3,
+             class [runtime]System.Collections.IEqualityComparer V_4)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0029
+
+    IL_0003:  ldarg.1
+    IL_0004:  isinst     XYZ.Expr
+    IL_0009:  stloc.0
+    IL_000a:  ldloc.0
+    IL_000b:  brfalse.s  IL_0027
+
+    IL_000d:  ldloc.0
+    IL_000e:  stloc.1
+    IL_000f:  ldarg.0
+    IL_0010:  pop
+    IL_0011:  ldarg.0
+    IL_0012:  stloc.2
+    IL_0013:  ldloc.1
+    IL_0014:  stloc.3
+    IL_0015:  ldarg.2
+    IL_0016:  stloc.s    V_4
+    IL_0018:  ldloc.2
+    IL_0019:  ldfld      int32 XYZ.Expr::item
+    IL_001e:  ldloc.3
+    IL_001f:  ldfld      int32 XYZ.Expr::item
+    IL_0024:  ceq
+    IL_0026:  ret
+
+    IL_0027:  ldc.i4.0
+    IL_0028:  ret
+
+    IL_0029:  ldarg.1
+    IL_002a:  ldnull
+    IL_002b:  cgt.un
+    IL_002d:  ldc.i4.0
+    IL_002e:  ceq
+    IL_0030:  ret
+  } 
+
+  .method public hidebysig virtual final instance bool  Equals(class XYZ.Expr obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0,
+             class XYZ.Expr V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_001d
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_001b
+
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  stloc.0
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  ldloc.0
+    IL_000d:  ldfld      int32 XYZ.Expr::item
+    IL_0012:  ldloc.1
+    IL_0013:  ldfld      int32 XYZ.Expr::item
+    IL_0018:  ceq
+    IL_001a:  ret
+
+    IL_001b:  ldc.i4.0
+    IL_001c:  ret
+
+    IL_001d:  ldarg.1
+    IL_001e:  ldnull
+    IL_001f:  cgt.un
+    IL_0021:  ldc.i4.0
+    IL_0022:  ceq
+    IL_0024:  ret
+  } 
+
+  .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class XYZ.Expr V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  isinst     XYZ.Expr
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_0012
+
+    IL_000a:  ldarg.0
+    IL_000b:  ldloc.0
+    IL_000c:  callvirt   instance bool XYZ.Expr::Equals(class XYZ.Expr)
+    IL_0011:  ret
+
+    IL_0012:  ldc.i4.0
+    IL_0013:  ret
+  } 
+
+  .property instance int32 Tag()
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .get instance int32 XYZ.Expr::get_Tag()
+  } 
+  .property instance int32 Item()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32,
+                                                                                                int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .get instance int32 XYZ.Expr::get_Item()
+  } 
+} 
+
+.class public auto ansi serializable beforefieldinit XYZ.MyExn
+       extends [runtime]System.Exception
+       implements [runtime]System.Collections.IStructuralEquatable
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+  .field assembly int32 Data0@
+  .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  ldarg.1
+    IL_0008:  stfld      int32 XYZ.MyExn::Data0@
+    IL_000d:  ret
+  } 
+
+  .method public specialname rtspecialname instance void  .ctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+    IL_0006:  ret
+  } 
+
+  .method family specialname rtspecialname 
+          instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                               valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  ldarg.2
+    IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                               valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+    IL_0008:  ret
+  } 
+
+  .method public hidebysig specialname instance int32 get_Data0() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      int32 XYZ.MyExn::Data0@
+    IL_0006:  ret
+  } 
+
+  .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  7
+    .locals init (int32 V_0,
+             class [runtime]System.Collections.IEqualityComparer V_1)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0023
+
+    IL_0003:  ldc.i4.0
+    IL_0004:  stloc.0
+    IL_0005:  ldc.i4     0x9e3779b9
+    IL_000a:  ldarg.1
+    IL_000b:  stloc.1
+    IL_000c:  ldarg.0
+    IL_000d:  castclass  XYZ.MyExn
+    IL_0012:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0017:  ldloc.0
+    IL_0018:  ldc.i4.6
+    IL_0019:  shl
+    IL_001a:  ldloc.0
+    IL_001b:  ldc.i4.2
+    IL_001c:  shr
+    IL_001d:  add
+    IL_001e:  add
+    IL_001f:  add
+    IL_0020:  stloc.0
+    IL_0021:  ldloc.0
+    IL_0022:  ret
+
+    IL_0023:  ldc.i4.0
+    IL_0024:  ret
+  } 
+
+  .method public hidebysig virtual instance int32 GetHashCode() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+    IL_0006:  callvirt   instance int32 XYZ.MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+    IL_000b:  ret
+  } 
+
+  .method public hidebysig virtual instance bool 
+          Equals(object obj,
+                 class [runtime]System.Collections.IEqualityComparer comp) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0,
+             class [runtime]System.Exception V_1,
+             object V_2,
+             class [runtime]System.Collections.IEqualityComparer V_3)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_003b
+
+    IL_0003:  ldarg.1
+    IL_0004:  isinst     [runtime]System.Exception
+    IL_0009:  stloc.0
+    IL_000a:  ldloc.0
+    IL_000b:  brfalse.s  IL_0039
+
+    IL_000d:  ldloc.0
+    IL_000e:  stloc.1
+    IL_000f:  ldloc.0
+    IL_0010:  stloc.2
+    IL_0011:  ldloc.2
+    IL_0012:  isinst     XYZ.MyExn
+    IL_0017:  ldnull
+    IL_0018:  cgt.un
+    IL_001a:  brfalse.s  IL_0037
+
+    IL_001c:  ldarg.2
+    IL_001d:  stloc.3
+    IL_001e:  ldarg.0
+    IL_001f:  castclass  XYZ.MyExn
+    IL_0024:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0029:  ldloc.1
+    IL_002a:  castclass  XYZ.MyExn
+    IL_002f:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0034:  ceq
+    IL_0036:  ret
+
+    IL_0037:  ldc.i4.0
+    IL_0038:  ret
+
+    IL_0039:  ldc.i4.0
+    IL_003a:  ret
+
+    IL_003b:  ldarg.1
+    IL_003c:  ldnull
+    IL_003d:  cgt.un
+    IL_003f:  ldc.i4.0
+    IL_0040:  ceq
+    IL_0042:  ret
+  } 
+
+  .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (object V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  brfalse.s  IL_0030
+
+    IL_0003:  ldarg.1
+    IL_0004:  brfalse.s  IL_002e
+
+    IL_0006:  ldarg.1
+    IL_0007:  stloc.0
+    IL_0008:  ldloc.0
+    IL_0009:  isinst     XYZ.MyExn
+    IL_000e:  ldnull
+    IL_000f:  cgt.un
+    IL_0011:  brfalse.s  IL_002c
+
+    IL_0013:  ldarg.0
+    IL_0014:  castclass  XYZ.MyExn
+    IL_0019:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_001e:  ldarg.1
+    IL_001f:  castclass  XYZ.MyExn
+    IL_0024:  call       instance int32 XYZ.MyExn::get_Data0()
+    IL_0029:  ceq
+    IL_002b:  ret
+
+    IL_002c:  ldc.i4.0
+    IL_002d:  ret
+
+    IL_002e:  ldc.i4.0
+    IL_002f:  ret
+
+    IL_0030:  ldarg.1
+    IL_0031:  ldnull
+    IL_0032:  cgt.un
+    IL_0034:  ldc.i4.0
+    IL_0035:  ceq
+    IL_0037:  ret
+  } 
+
+  .method public hidebysig virtual instance bool Equals(object obj) cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [runtime]System.Exception V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  isinst     [runtime]System.Exception
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_0012
+
+    IL_000a:  ldarg.0
+    IL_000b:  ldloc.0
+    IL_000c:  callvirt   instance bool XYZ.MyExn::Equals(class [runtime]System.Exception)
+    IL_0011:  ret
+
+    IL_0012:  ldc.i4.0
+    IL_0013:  ret
+  } 
+
+  .property instance int32 Data0()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+    .get instance int32 XYZ.MyExn::get_Data0()
+  } 
+} 
+
+.class public auto ansi serializable XYZ.A
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+  .field assembly string x
+  .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+    IL_0006:  ldarg.0
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  ldarg.1
+    IL_000a:  stfld      string XYZ.A::x
+    IL_000f:  ret
+  } 
+
+  .method public hidebysig specialname instance string get_X() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldfld      string XYZ.A::x
+    IL_0006:  ret
+  } 
+
+  .property instance string X()
+  {
+    .get instance string XYZ.A::get_X()
+  } 
+} 
+
+.class public abstract auto ansi sealed XYZ.ABC
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto autochar serializable sealed nested public beforefieldinit Expr
+         extends [runtime]System.Object
+         implements class [runtime]System.IEquatable`1<class XYZ.ABC/Expr>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<class XYZ.ABC/Expr>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                         61 79 28 29 2C 6E 71 7D 00 00 )                   
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+    .field assembly initonly int32 item
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method public static class XYZ.ABC/Expr NewNum(int32 item) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  newobj     instance void XYZ.ABC/Expr::.ctor(int32)
+      IL_0006:  ret
+    } 
+
+    .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+    {
+      .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                              class [runtime]System.Type) = ( 01 00 60 06 00 00 0C 58 59 5A 2E 41 42 43 2B 45   
+                                                                                                                                                     78 70 72 00 00 )                                  
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 XYZ.ABC/Expr::item
+      IL_000d:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Item() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig instance int32 get_Tag() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  pop
+      IL_0002:  ldc.i4.0
+      IL_0003:  ret
+    } 
+
+    .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+0.8A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public strict virtual instance string ToString() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "%+A"
+      IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/Expr>::.ctor(string)
+      IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+      IL_000f:  ldarg.0
+      IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/Expr,string>::Invoke(!0)
+      IL_0015:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(class XYZ.ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               int32 V_3,
+               int32 V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_002f
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002d
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.0
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  stloc.3
+      IL_0019:  ldloc.1
+      IL_001a:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.3
+      IL_0022:  ldloc.s    V_4
+      IL_0024:  cgt
+      IL_0026:  ldloc.3
+      IL_0027:  ldloc.s    V_4
+      IL_0029:  clt
+      IL_002b:  sub
+      IL_002c:  ret
+
+      IL_002d:  ldc.i4.1
+      IL_002e:  ret
+
+      IL_002f:  ldarg.1
+      IL_0030:  brfalse.s  IL_0034
+
+      IL_0032:  ldc.i4.m1
+      IL_0033:  ret
+
+      IL_0034:  ldc.i4.0
+      IL_0035:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  XYZ.ABC/Expr
+      IL_0007:  callvirt   instance int32 XYZ.ABC/Expr::CompareTo(class XYZ.ABC/Expr)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class XYZ.ABC/Expr V_2,
+               class [runtime]System.Collections.IComparer V_3,
+               int32 V_4,
+               int32 V_5)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  XYZ.ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldarg.0
+      IL_0008:  brfalse.s  IL_003a
+
+      IL_000a:  ldarg.1
+      IL_000b:  unbox.any  XYZ.ABC/Expr
+      IL_0010:  brfalse.s  IL_0038
+
+      IL_0012:  ldarg.0
+      IL_0013:  pop
+      IL_0014:  ldarg.0
+      IL_0015:  stloc.1
+      IL_0016:  ldloc.0
+      IL_0017:  stloc.2
+      IL_0018:  ldarg.2
+      IL_0019:  stloc.3
+      IL_001a:  ldloc.1
+      IL_001b:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0020:  stloc.s    V_4
+      IL_0022:  ldloc.2
+      IL_0023:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0028:  stloc.s    V_5
+      IL_002a:  ldloc.s    V_4
+      IL_002c:  ldloc.s    V_5
+      IL_002e:  cgt
+      IL_0030:  ldloc.s    V_4
+      IL_0032:  ldloc.s    V_5
+      IL_0034:  clt
+      IL_0036:  sub
+      IL_0037:  ret
+
+      IL_0038:  ldc.i4.1
+      IL_0039:  ret
+
+      IL_003a:  ldarg.1
+      IL_003b:  unbox.any  XYZ.ABC/Expr
+      IL_0040:  brfalse.s  IL_0044
+
+      IL_0042:  ldc.i4.m1
+      IL_0043:  ret
+
+      IL_0044:  ldc.i4.0
+      IL_0045:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class XYZ.ABC/Expr V_1,
+               class [runtime]System.Collections.IEqualityComparer V_2)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0024
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldarg.0
+      IL_0006:  pop
+      IL_0007:  ldarg.0
+      IL_0008:  stloc.1
+      IL_0009:  ldc.i4.0
+      IL_000a:  stloc.0
+      IL_000b:  ldc.i4     0x9e3779b9
+      IL_0010:  ldarg.1
+      IL_0011:  stloc.2
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  ldloc.0
+      IL_0019:  ldc.i4.6
+      IL_001a:  shl
+      IL_001b:  ldloc.0
+      IL_001c:  ldc.i4.2
+      IL_001d:  shr
+      IL_001e:  add
+      IL_001f:  add
+      IL_0020:  add
+      IL_0021:  stloc.0
+      IL_0022:  ldloc.0
+      IL_0023:  ret
+
+      IL_0024:  ldc.i4.0
+      IL_0025:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 XYZ.ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1,
+               class XYZ.ABC/Expr V_2,
+               class XYZ.ABC/Expr V_3,
+               class [runtime]System.Collections.IEqualityComparer V_4)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0029
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     XYZ.ABC/Expr
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0027
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldarg.0
+      IL_0010:  pop
+      IL_0011:  ldarg.0
+      IL_0012:  stloc.2
+      IL_0013:  ldloc.1
+      IL_0014:  stloc.3
+      IL_0015:  ldarg.2
+      IL_0016:  stloc.s    V_4
+      IL_0018:  ldloc.2
+      IL_0019:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_001e:  ldloc.3
+      IL_001f:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0024:  ceq
+      IL_0026:  ret
+
+      IL_0027:  ldc.i4.0
+      IL_0028:  ret
+
+      IL_0029:  ldarg.1
+      IL_002a:  ldnull
+      IL_002b:  cgt.un
+      IL_002d:  ldc.i4.0
+      IL_002e:  ceq
+      IL_0030:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(class XYZ.ABC/Expr obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0,
+               class XYZ.ABC/Expr V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_001d
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_001b
+
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  stloc.0
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldloc.0
+      IL_000d:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      int32 XYZ.ABC/Expr::item
+      IL_0018:  ceq
+      IL_001a:  ret
+
+      IL_001b:  ldc.i4.0
+      IL_001c:  ret
+
+      IL_001d:  ldarg.1
+      IL_001e:  ldnull
+      IL_001f:  cgt.un
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class XYZ.ABC/Expr V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     XYZ.ABC/Expr
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool XYZ.ABC/Expr::Equals(class XYZ.ABC/Expr)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Tag()
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .get instance int32 XYZ.ABC/Expr::get_Tag()
+    } 
+    .property instance int32 Item()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .get instance int32 XYZ.ABC/Expr::get_Item()
+    } 
+  } 
+
+  .class auto ansi serializable nested public beforefieldinit MyExn
+         extends [runtime]System.Exception
+         implements [runtime]System.Collections.IStructuralEquatable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+    .field assembly int32 Data0@
+    .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      int32 XYZ.ABC/MyExn::Data0@
+      IL_000d:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method family specialname rtspecialname 
+            instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  ldarg.2
+      IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                                 valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+      IL_0008:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_Data0() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 XYZ.ABC/MyExn::Data0@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0,
+               class [runtime]System.Collections.IEqualityComparer V_1)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0023
+
+      IL_0003:  ldc.i4.0
+      IL_0004:  stloc.0
+      IL_0005:  ldc.i4     0x9e3779b9
+      IL_000a:  ldarg.1
+      IL_000b:  stloc.1
+      IL_000c:  ldarg.0
+      IL_000d:  castclass  XYZ.ABC/MyExn
+      IL_0012:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0017:  ldloc.0
+      IL_0018:  ldc.i4.6
+      IL_0019:  shl
+      IL_001a:  ldloc.0
+      IL_001b:  ldc.i4.2
+      IL_001c:  shr
+      IL_001d:  add
+      IL_001e:  add
+      IL_001f:  add
+      IL_0020:  stloc.0
+      IL_0021:  ldloc.0
+      IL_0022:  ret
+
+      IL_0023:  ldc.i4.0
+      IL_0024:  ret
+    } 
+
+    .method public hidebysig virtual instance int32 GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  callvirt   instance int32 XYZ.ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual instance bool 
+            Equals(object obj,
+                   class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0,
+               class [runtime]System.Exception V_1,
+               object V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_003b
+
+      IL_0003:  ldarg.1
+      IL_0004:  isinst     [runtime]System.Exception
+      IL_0009:  stloc.0
+      IL_000a:  ldloc.0
+      IL_000b:  brfalse.s  IL_0039
+
+      IL_000d:  ldloc.0
+      IL_000e:  stloc.1
+      IL_000f:  ldloc.0
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.2
+      IL_0012:  isinst     XYZ.ABC/MyExn
+      IL_0017:  ldnull
+      IL_0018:  cgt.un
+      IL_001a:  brfalse.s  IL_0037
+
+      IL_001c:  ldarg.2
+      IL_001d:  stloc.3
+      IL_001e:  ldarg.0
+      IL_001f:  castclass  XYZ.ABC/MyExn
+      IL_0024:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0029:  ldloc.1
+      IL_002a:  castclass  XYZ.ABC/MyExn
+      IL_002f:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0034:  ceq
+      IL_0036:  ret
+
+      IL_0037:  ldc.i4.0
+      IL_0038:  ret
+
+      IL_0039:  ldc.i4.0
+      IL_003a:  ret
+
+      IL_003b:  ldarg.1
+      IL_003c:  ldnull
+      IL_003d:  cgt.un
+      IL_003f:  ldc.i4.0
+      IL_0040:  ceq
+      IL_0042:  ret
+    } 
+
+    .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  brfalse.s  IL_0030
+
+      IL_0003:  ldarg.1
+      IL_0004:  brfalse.s  IL_002e
+
+      IL_0006:  ldarg.1
+      IL_0007:  stloc.0
+      IL_0008:  ldloc.0
+      IL_0009:  isinst     XYZ.ABC/MyExn
+      IL_000e:  ldnull
+      IL_000f:  cgt.un
+      IL_0011:  brfalse.s  IL_002c
+
+      IL_0013:  ldarg.0
+      IL_0014:  castclass  XYZ.ABC/MyExn
+      IL_0019:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_001e:  ldarg.1
+      IL_001f:  castclass  XYZ.ABC/MyExn
+      IL_0024:  call       instance int32 XYZ.ABC/MyExn::get_Data0()
+      IL_0029:  ceq
+      IL_002b:  ret
+
+      IL_002c:  ldc.i4.0
+      IL_002d:  ret
+
+      IL_002e:  ldc.i4.0
+      IL_002f:  ret
+
+      IL_0030:  ldarg.1
+      IL_0031:  ldnull
+      IL_0032:  cgt.un
+      IL_0034:  ldc.i4.0
+      IL_0035:  ceq
+      IL_0037:  ret
+    } 
+
+    .method public hidebysig virtual instance bool Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (class [runtime]System.Exception V_0)
+      IL_0000:  ldarg.1
+      IL_0001:  isinst     [runtime]System.Exception
+      IL_0006:  stloc.0
+      IL_0007:  ldloc.0
+      IL_0008:  brfalse.s  IL_0012
+
+      IL_000a:  ldarg.0
+      IL_000b:  ldloc.0
+      IL_000c:  callvirt   instance bool XYZ.ABC/MyExn::Equals(class [runtime]System.Exception)
+      IL_0011:  ret
+
+      IL_0012:  ldc.i4.0
+      IL_0013:  ret
+    } 
+
+    .property instance int32 Data0()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance int32 XYZ.ABC/MyExn::get_Data0()
+    } 
+  } 
+
+  .class auto ansi serializable nested public A
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly string x
+    .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldarg.1
+      IL_000a:  stfld      string XYZ.ABC/A::x
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance string  get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      string XYZ.ABC/A::x
+      IL_0006:  ret
+    } 
+
+    .property instance string X()
+    {
+      .get instance string XYZ.ABC/A::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public ABC
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class auto autochar serializable sealed nested public beforefieldinit Expr
+           extends [runtime]System.Object
+           implements class [runtime]System.IEquatable`1<class XYZ.ABC/ABC/Expr>,
+                      [runtime]System.Collections.IStructuralEquatable,
+                      class [runtime]System.IComparable`1<class XYZ.ABC/ABC/Expr>,
+                      [runtime]System.IComparable,
+                      [runtime]System.Collections.IStructuralComparable
+    {
+      .custom instance void [runtime]System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = ( 01 00 15 7B 5F 5F 44 65 62 75 67 44 69 73 70 6C   
+                                                                                                           61 79 28 29 2C 6E 71 7D 00 00 )                   
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 01 00 00 00 00 00 ) 
+      .field assembly initonly int32 item
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      .method public static class XYZ.ABC/ABC/Expr NewNum(int32 item) cil managed
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 08 00 00 00 00 00 00 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  newobj     instance void XYZ.ABC/ABC/Expr::.ctor(int32)
+        IL_0006:  ret
+      } 
+
+      .method assembly specialname rtspecialname instance void  .ctor(int32 item) cil managed
+      {
+        .custom instance void [runtime]System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute::.ctor(valuetype [runtime]System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes,
+                                                                                                                class [runtime]System.Type) = ( 01 00 60 06 00 00 10 58 59 5A 2E 41 42 43 2B 41   
+                                                                                                                                                       42 43 2B 45 78 70 72 00 00 )                      
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_000d:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Item() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig instance int32 get_Tag() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  pop
+        IL_0002:  ldc.i4.0
+        IL_0003:  ret
+      } 
+
+      .method assembly hidebysig specialname instance object  __DebugDisplay() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+0.8A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,string>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public strict virtual instance string ToString() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldstr      "%+A"
+        IL_0005:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string,class XYZ.ABC/ABC/Expr>::.ctor(string)
+        IL_000a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatToString<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [FSharp.Core]Microsoft.FSharp.Core.Unit,string,string>)
+        IL_000f:  ldarg.0
+        IL_0010:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class XYZ.ABC/ABC/Expr,string>::Invoke(!0)
+        IL_0015:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(class XYZ.ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IComparer V_2,
+                 int32 V_3,
+                 int32 V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_002f
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002d
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.0
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  stloc.3
+        IL_0019:  ldloc.1
+        IL_001a:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_001f:  stloc.s    V_4
+        IL_0021:  ldloc.3
+        IL_0022:  ldloc.s    V_4
+        IL_0024:  cgt
+        IL_0026:  ldloc.3
+        IL_0027:  ldloc.s    V_4
+        IL_0029:  clt
+        IL_002b:  sub
+        IL_002c:  ret
+
+        IL_002d:  ldc.i4.1
+        IL_002e:  ret
+
+        IL_002f:  ldarg.1
+        IL_0030:  brfalse.s  IL_0034
+
+        IL_0032:  ldc.i4.m1
+        IL_0033:  ret
+
+        IL_0034:  ldc.i4.0
+        IL_0035:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0007:  callvirt   instance int32 XYZ.ABC/ABC/Expr::CompareTo(class XYZ.ABC/ABC/Expr)
+        IL_000c:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance int32  CompareTo(object obj,
+                                        class [runtime]System.Collections.IComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  5
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class XYZ.ABC/ABC/Expr V_2,
+                 class [runtime]System.Collections.IComparer V_3,
+                 int32 V_4,
+                 int32 V_5)
+        IL_0000:  ldarg.1
+        IL_0001:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldarg.0
+        IL_0008:  brfalse.s  IL_003a
+
+        IL_000a:  ldarg.1
+        IL_000b:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0010:  brfalse.s  IL_0038
+
+        IL_0012:  ldarg.0
+        IL_0013:  pop
+        IL_0014:  ldarg.0
+        IL_0015:  stloc.1
+        IL_0016:  ldloc.0
+        IL_0017:  stloc.2
+        IL_0018:  ldarg.2
+        IL_0019:  stloc.3
+        IL_001a:  ldloc.1
+        IL_001b:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0020:  stloc.s    V_4
+        IL_0022:  ldloc.2
+        IL_0023:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0028:  stloc.s    V_5
+        IL_002a:  ldloc.s    V_4
+        IL_002c:  ldloc.s    V_5
+        IL_002e:  cgt
+        IL_0030:  ldloc.s    V_4
+        IL_0032:  ldloc.s    V_5
+        IL_0034:  clt
+        IL_0036:  sub
+        IL_0037:  ret
+
+        IL_0038:  ldc.i4.1
+        IL_0039:  ret
+
+        IL_003a:  ldarg.1
+        IL_003b:  unbox.any  XYZ.ABC/ABC/Expr
+        IL_0040:  brfalse.s  IL_0044
+
+        IL_0042:  ldc.i4.m1
+        IL_0043:  ret
+
+        IL_0044:  ldc.i4.0
+        IL_0045:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class [runtime]System.Collections.IEqualityComparer V_2)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0024
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldarg.0
+        IL_0006:  pop
+        IL_0007:  ldarg.0
+        IL_0008:  stloc.1
+        IL_0009:  ldc.i4.0
+        IL_000a:  stloc.0
+        IL_000b:  ldc.i4     0x9e3779b9
+        IL_0010:  ldarg.1
+        IL_0011:  stloc.2
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  ldloc.0
+        IL_0019:  ldc.i4.6
+        IL_001a:  shl
+        IL_001b:  ldloc.0
+        IL_001c:  ldc.i4.2
+        IL_001d:  shr
+        IL_001e:  add
+        IL_001f:  add
+        IL_0020:  add
+        IL_0021:  stloc.0
+        IL_0022:  ldloc.0
+        IL_0023:  ret
+
+        IL_0024:  ldc.i4.0
+        IL_0025:  ret
+      } 
+
+      .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 XYZ.ABC/ABC/Expr::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual final 
+              instance bool  Equals(object obj,
+                                    class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1,
+                 class XYZ.ABC/ABC/Expr V_2,
+                 class XYZ.ABC/ABC/Expr V_3,
+                 class [runtime]System.Collections.IEqualityComparer V_4)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0029
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     XYZ.ABC/ABC/Expr
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0027
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldarg.0
+        IL_0010:  pop
+        IL_0011:  ldarg.0
+        IL_0012:  stloc.2
+        IL_0013:  ldloc.1
+        IL_0014:  stloc.3
+        IL_0015:  ldarg.2
+        IL_0016:  stloc.s    V_4
+        IL_0018:  ldloc.2
+        IL_0019:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_001e:  ldloc.3
+        IL_001f:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0024:  ceq
+        IL_0026:  ret
+
+        IL_0027:  ldc.i4.0
+        IL_0028:  ret
+
+        IL_0029:  ldarg.1
+        IL_002a:  ldnull
+        IL_002b:  cgt.un
+        IL_002d:  ldc.i4.0
+        IL_002e:  ceq
+        IL_0030:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(class XYZ.ABC/ABC/Expr obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0,
+                 class XYZ.ABC/ABC/Expr V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_001d
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_001b
+
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  stloc.0
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldloc.0
+        IL_000d:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0012:  ldloc.1
+        IL_0013:  ldfld      int32 XYZ.ABC/ABC/Expr::item
+        IL_0018:  ceq
+        IL_001a:  ret
+
+        IL_001b:  ldc.i4.0
+        IL_001c:  ret
+
+        IL_001d:  ldarg.1
+        IL_001e:  ldnull
+        IL_001f:  cgt.un
+        IL_0021:  ldc.i4.0
+        IL_0022:  ceq
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class XYZ.ABC/ABC/Expr V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     XYZ.ABC/ABC/Expr
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool XYZ.ABC/ABC/Expr::Equals(class XYZ.ABC/ABC/Expr)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Tag()
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/Expr::get_Tag()
+      } 
+      .property instance int32 Item()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/Expr::get_Item()
+      } 
+    } 
+
+    .class auto ansi serializable nested public beforefieldinit MyExn
+           extends [runtime]System.Exception
+           implements [runtime]System.Collections.IStructuralEquatable
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 05 00 00 00 00 00 ) 
+      .field assembly int32 Data0@
+      .method public specialname rtspecialname instance void  .ctor(int32 data0) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  ldarg.1
+        IL_0008:  stfld      int32 XYZ.ABC/ABC/MyExn::Data0@
+        IL_000d:  ret
+      } 
+
+      .method public specialname rtspecialname instance void  .ctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       instance void [runtime]System.Exception::.ctor()
+        IL_0006:  ret
+      } 
+
+      .method family specialname rtspecialname 
+              instance void  .ctor(class [runtime]System.Runtime.Serialization.SerializationInfo info,
+                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext context) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldarg.1
+        IL_0002:  ldarg.2
+        IL_0003:  call       instance void [runtime]System.Exception::.ctor(class [runtime]System.Runtime.Serialization.SerializationInfo,
+                                                                                   valuetype [runtime]System.Runtime.Serialization.StreamingContext)
+        IL_0008:  ret
+      } 
+
+      .method public hidebysig specialname instance int32  get_Data0() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      int32 XYZ.ABC/ABC/MyExn::Data0@
+        IL_0006:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  7
+        .locals init (int32 V_0,
+                 class [runtime]System.Collections.IEqualityComparer V_1)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0023
+
+        IL_0003:  ldc.i4.0
+        IL_0004:  stloc.0
+        IL_0005:  ldc.i4     0x9e3779b9
+        IL_000a:  ldarg.1
+        IL_000b:  stloc.1
+        IL_000c:  ldarg.0
+        IL_000d:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0012:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0017:  ldloc.0
+        IL_0018:  ldc.i4.6
+        IL_0019:  shl
+        IL_001a:  ldloc.0
+        IL_001b:  ldc.i4.2
+        IL_001c:  shr
+        IL_001d:  add
+        IL_001e:  add
+        IL_001f:  add
+        IL_0020:  stloc.0
+        IL_0021:  ldloc.0
+        IL_0022:  ret
+
+        IL_0023:  ldc.i4.0
+        IL_0024:  ret
+      } 
+
+      .method public hidebysig virtual instance int32 GetHashCode() cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+        IL_0006:  callvirt   instance int32 XYZ.ABC/ABC/MyExn::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+        IL_000b:  ret
+      } 
+
+      .method public hidebysig virtual instance bool 
+              Equals(object obj,
+                     class [runtime]System.Collections.IEqualityComparer comp) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0,
+                 class [runtime]System.Exception V_1,
+                 object V_2,
+                 class [runtime]System.Collections.IEqualityComparer V_3)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_003b
+
+        IL_0003:  ldarg.1
+        IL_0004:  isinst     [runtime]System.Exception
+        IL_0009:  stloc.0
+        IL_000a:  ldloc.0
+        IL_000b:  brfalse.s  IL_0039
+
+        IL_000d:  ldloc.0
+        IL_000e:  stloc.1
+        IL_000f:  ldloc.0
+        IL_0010:  stloc.2
+        IL_0011:  ldloc.2
+        IL_0012:  isinst     XYZ.ABC/ABC/MyExn
+        IL_0017:  ldnull
+        IL_0018:  cgt.un
+        IL_001a:  brfalse.s  IL_0037
+
+        IL_001c:  ldarg.2
+        IL_001d:  stloc.3
+        IL_001e:  ldarg.0
+        IL_001f:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0024:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ldloc.1
+        IL_002a:  castclass  XYZ.ABC/ABC/MyExn
+        IL_002f:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0034:  ceq
+        IL_0036:  ret
+
+        IL_0037:  ldc.i4.0
+        IL_0038:  ret
+
+        IL_0039:  ldc.i4.0
+        IL_003a:  ret
+
+        IL_003b:  ldarg.1
+        IL_003c:  ldnull
+        IL_003d:  cgt.un
+        IL_003f:  ldc.i4.0
+        IL_0040:  ceq
+        IL_0042:  ret
+      } 
+
+      .method public hidebysig instance bool Equals(class [runtime]System.Exception obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (object V_0)
+        IL_0000:  ldarg.0
+        IL_0001:  brfalse.s  IL_0030
+
+        IL_0003:  ldarg.1
+        IL_0004:  brfalse.s  IL_002e
+
+        IL_0006:  ldarg.1
+        IL_0007:  stloc.0
+        IL_0008:  ldloc.0
+        IL_0009:  isinst     XYZ.ABC/ABC/MyExn
+        IL_000e:  ldnull
+        IL_000f:  cgt.un
+        IL_0011:  brfalse.s  IL_002c
+
+        IL_0013:  ldarg.0
+        IL_0014:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0019:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_001e:  ldarg.1
+        IL_001f:  castclass  XYZ.ABC/ABC/MyExn
+        IL_0024:  call       instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+        IL_0029:  ceq
+        IL_002b:  ret
+
+        IL_002c:  ldc.i4.0
+        IL_002d:  ret
+
+        IL_002e:  ldc.i4.0
+        IL_002f:  ret
+
+        IL_0030:  ldarg.1
+        IL_0031:  ldnull
+        IL_0032:  cgt.un
+        IL_0034:  ldc.i4.0
+        IL_0035:  ceq
+        IL_0037:  ret
+      } 
+
+      .method public hidebysig virtual instance bool Equals(object obj) cil managed
+      {
+        .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+        
+        .maxstack  4
+        .locals init (class [runtime]System.Exception V_0)
+        IL_0000:  ldarg.1
+        IL_0001:  isinst     [runtime]System.Exception
+        IL_0006:  stloc.0
+        IL_0007:  ldloc.0
+        IL_0008:  brfalse.s  IL_0012
+
+        IL_000a:  ldarg.0
+        IL_000b:  ldloc.0
+        IL_000c:  callvirt   instance bool XYZ.ABC/ABC/MyExn::Equals(class [runtime]System.Exception)
+        IL_0011:  ret
+
+        IL_0012:  ldc.i4.0
+        IL_0013:  ret
+      } 
+
+      .property instance int32 Data0()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                    int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+        .get instance int32 XYZ.ABC/ABC/MyExn::get_Data0()
+      } 
+    } 
+
+    .class auto ansi serializable nested public A
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+      .field assembly string x
+      .method public specialname rtspecialname instance void  .ctor(string x) cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+        IL_0006:  ldarg.0
+        IL_0007:  pop
+        IL_0008:  ldarg.0
+        IL_0009:  ldarg.1
+        IL_000a:  stfld      string XYZ.ABC/ABC/A::x
+        IL_000f:  ret
+      } 
+
+      .method public hidebysig specialname instance string  get_X() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldarg.0
+        IL_0001:  ldfld      string XYZ.ABC/ABC/A::x
+        IL_0006:  ret
+      } 
+
+      .property instance string X()
+      {
+        .get instance string XYZ.ABC/ABC/A::get_X()
+      } 
+    } 
+
+    .method public static int32  'add'(int32 x,
+                                       int32 y) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  add
+      IL_0003:  ret
+    } 
+
+    .method public specialname static string get_greeting() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldstr      "hello"
+      IL_0005:  ret
+    } 
+
+    .property string greeting()
+    {
+      .get string XYZ.ABC/ABC::get_greeting()
+    } 
+  } 
+
+  .method public static int32  'add'(int32 x,
+                                     int32 y) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  add
+    IL_0003:  ret
+  } 
+
+  .method public specialname static string get_greeting() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldstr      "hello"
+    IL_0005:  ret
+  } 
+
+  .property string greeting()
+  {
+    .get string XYZ.ABC::get_greeting()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/LetBinding01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/LetBinding01.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/LetBinding01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/LetBinding01.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/LetBinding01.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/LetBinding01.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..5168ea5996e
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/LetBinding01.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,110 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Core.Unit get_x() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldnull
+    IL_0001:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ldstr      "x = %A"
+    IL_0006:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_000b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0010:  call       class [FSharp.Core]Microsoft.FSharp.Core.Unit assembly::get_x()
+    IL_0015:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_001a:  pop
+    IL_001b:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Core.Unit
+          x()
+  {
+    .get class [FSharp.Core]Microsoft.FSharp.Core.Unit assembly::get_x()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit.fs
index 3cc63ea37e6..2f9a1277528 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open Xunit
 open System.IO
@@ -17,27 +17,58 @@ module StaticInit =
         |> ignoreWarnings
         |> verifyILBaseline
 
+    // SOURCE=LetBinding01.fs SCFLAGS="   -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd LetBinding01.exe"			# LetBinding01.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"LetBinding01.fs"|])>]
+    let ``LetBinding01_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
 
     // SOURCE=LetBinding01.fs SCFLAGS="   -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd LetBinding01.exe"			# LetBinding01.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"LetBinding01.fs"|])>]
-    let ``LetBinding01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"LetBinding01.fs"|])>]
+    let ``LetBinding01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=StaticInit_Struct01.fs SCFLAGS="-a -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd StaticInit_Struct01.dll"	# StaticInit_Struct01.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"StaticInit_Struct01.fs"|])>]
+    let ``StaticInit_Struct01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=StaticInit_Struct01.fs SCFLAGS="-a -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd StaticInit_Struct01.dll"	# StaticInit_Struct01.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"StaticInit_Struct01.fs"|])>]
-    let ``StaticInit_Struct01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"StaticInit_Struct01.fs"|])>]
+    let ``StaticInit_Struct01_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     // SOURCE=StaticInit_Class01.fs SCFLAGS="-a -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd StaticInit_Class01.dll"	# StaticInit_Class01.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"StaticInit_Class01.fs"|])>]
-    let ``StaticInit_Class01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"StaticInit_Class01.fs"|])>]
+    let ``StaticInit_Class01_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    // SOURCE=StaticInit_Class01.fs SCFLAGS="-a -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd StaticInit_Class01.dll"	# StaticInit_Class01.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"StaticInit_Class01.fs"|])>]
+    let ``StaticInit_Class01_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=StaticInit_Module01.fs SCFLAGS="-a -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd StaticInit_Module01.dll"	# StaticInit_Module01.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"StaticInit_Module01.fs"|])>]
+    let ``StaticInit_Module01_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=StaticInit_Module01.fs SCFLAGS="-a -g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd StaticInit_Module01.dll"	# StaticInit_Module01.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"StaticInit_Module01.fs"|])>]
-    let ``StaticInit_Module01_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"StaticInit_Module01.fs"|])>]
+    let ``StaticInit_Module01_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Class01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Class01.fs.RealInternalSignatureOff.il.bsl
similarity index 96%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Class01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Class01.fs.RealInternalSignatureOff.il.bsl
index f66d450930c..ca32e90a5c8 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Class01.fs.il.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Class01.fs.RealInternalSignatureOff.il.bsl
@@ -1,131 +1,131 @@
-
-
-
-
-
-.assembly extern runtime { }
-.assembly extern FSharp.Core { }
-.assembly assembly
-{
-  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
-                                                                                                      int32,
-                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
-
-  
-  
-
-  .hash algorithm 0x00008004
-  .ver 0:0:0:0
-}
-.mresource public FSharpSignatureData.assembly
-{
-  
-  
-}
-.mresource public FSharpOptimizationData.assembly
-{
-  
-  
-}
-.module assembly.exe
-
-.imagebase {value}
-.file alignment 0x00000200
-.stackreserve 0x00100000
-.subsystem 0x0003       
-.corflags 0x00000001    
-
-
-
-
-
-.class public abstract auto ansi sealed StaticInit_ClassS01
-       extends [runtime]System.Object
-{
-  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
-  .class auto ansi serializable nested public C
-         extends [runtime]System.Object
-  {
-    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
-    .field static assembly int32 x
-    .field static assembly int32 init@4
-    .method public specialname rtspecialname 
-            instance void  .ctor(valuetype [runtime]System.DateTime s) cil managed
-    {
-      
-      .maxstack  8
-      IL_0000:  ldarg.0
-      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
-      IL_0006:  ldarg.0
-      IL_0007:  pop
-      IL_0008:  ret
-    } 
-
-    .method assembly static int32  f() cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  8
-      IL_0000:  nop
-      IL_0001:  volatile.
-      IL_0003:  ldsfld     int32 StaticInit_ClassS01/C::init@4
-      IL_0008:  ldc.i4.1
-      IL_0009:  bge.s      IL_0014
-
-      IL_000b:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
-      IL_0010:  nop
-      IL_0011:  nop
-      IL_0012:  br.s       IL_0015
-
-      IL_0014:  nop
-      IL_0015:  ldsfld     int32 StaticInit_ClassS01/C::x
-      IL_001a:  ldstr      "2"
-      IL_001f:  callvirt   instance int32 [runtime]System.String::get_Length()
-      IL_0024:  add
-      IL_0025:  ret
-    } 
-
-    .method private specialname rtspecialname static 
-            void  .cctor() cil managed
-    {
-      
-      .maxstack  8
-      IL_0000:  ldc.i4.0
-      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$StaticInit_ClassS01::init@
-      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$StaticInit_ClassS01::init@
-      IL_000b:  pop
-      IL_000c:  ret
-    } 
-
-  } 
-
-} 
-
-.class private abstract auto ansi sealed '<StartupCode$assembly>'.$StaticInit_ClassS01
-       extends [runtime]System.Object
-{
-  .field static assembly int32 init@
-  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-  .method public static void  main@() cil managed
-  {
-    .entrypoint
-    
-    .maxstack  8
-    IL_0000:  ldstr      "1"
-    IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
-    IL_000a:  stsfld     int32 StaticInit_ClassS01/C::x
-    IL_000f:  ldc.i4.1
-    IL_0010:  volatile.
-    IL_0012:  stsfld     int32 StaticInit_ClassS01/C::init@4
-    IL_0017:  ret
-  } 
-
-} 
-
-
-
-
-
-
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed StaticInit_ClassS01
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public C
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field static assembly int32 x
+    .field static assembly int32 init@4
+    .method public specialname rtspecialname 
+            instance void  .ctor(valuetype [runtime]System.DateTime s) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method assembly static int32  f() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  nop
+      IL_0001:  volatile.
+      IL_0003:  ldsfld     int32 StaticInit_ClassS01/C::init@4
+      IL_0008:  ldc.i4.1
+      IL_0009:  bge.s      IL_0014
+
+      IL_000b:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_0010:  nop
+      IL_0011:  nop
+      IL_0012:  br.s       IL_0015
+
+      IL_0014:  nop
+      IL_0015:  ldsfld     int32 StaticInit_ClassS01/C::x
+      IL_001a:  ldstr      "2"
+      IL_001f:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0024:  add
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$StaticInit_ClassS01::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$StaticInit_ClassS01::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$StaticInit_ClassS01
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ldstr      "1"
+    IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000a:  stsfld     int32 StaticInit_ClassS01/C::x
+    IL_000f:  ldc.i4.1
+    IL_0010:  volatile.
+    IL_0012:  stsfld     int32 StaticInit_ClassS01/C::init@4
+    IL_0017:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Class01.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Class01.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..0e57f39883d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Class01.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,156 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed StaticInit_ClassS01
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public C
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field static assembly int32 x
+    .field static assembly int32 init@4
+    .method public specialname rtspecialname instance void  .ctor(valuetype [runtime]System.DateTime s) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method assembly static int32  f() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  nop
+      IL_0001:  volatile.
+      IL_0003:  ldsfld     int32 StaticInit_ClassS01/C::init@4
+      IL_0008:  ldc.i4.1
+      IL_0009:  bge.s      IL_0014
+
+      IL_000b:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_0010:  nop
+      IL_0011:  nop
+      IL_0012:  br.s       IL_0015
+
+      IL_0014:  nop
+      IL_0015:  ldsfld     int32 StaticInit_ClassS01/C::x
+      IL_001a:  ldstr      "2"
+      IL_001f:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0024:  add
+      IL_0025:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$StaticInit_ClassS01::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$StaticInit_ClassS01::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldstr      "1"
+      IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_000a:  stsfld     int32 StaticInit_ClassS01/C::x
+      IL_000f:  ldc.i4.1
+      IL_0010:  volatile.
+      IL_0012:  stsfld     int32 StaticInit_ClassS01/C::init@4
+      IL_0017:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$StaticInit_ClassS01::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$StaticInit_ClassS01::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void StaticInit_ClassS01/C::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$StaticInit_ClassS01
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void StaticInit_ClassS01::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Module01.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Module01.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Module01.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Module01.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Module01.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Module01.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..870e8d0ba3d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Module01.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,196 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto ansi sealed nested public M
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .class abstract auto ansi sealed nested public N
+           extends [runtime]System.Object
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+      .field static assembly int32 y@7
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .field static assembly int32 z@8
+      .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+      .method public specialname static int32 get_y() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldsfld     int32 assembly/M/N::y@7
+        IL_0005:  ret
+      } 
+
+      .method public specialname static int32 get_z() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldsfld     int32 assembly/M/N::z@8
+        IL_0005:  ret
+      } 
+
+      .method private specialname rtspecialname static void  .cctor() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  ldc.i4.0
+        IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+        IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+        IL_000b:  pop
+        IL_000c:  ret
+      } 
+
+      .method assembly specialname static void  staticInitialization@() cil managed
+      {
+        
+        .maxstack  8
+        IL_0000:  call       int32 assembly/M::get_x()
+        IL_0005:  ldstr      "2"
+        IL_000a:  callvirt   instance int32 [runtime]System.String::get_Length()
+        IL_000f:  add
+        IL_0010:  stsfld     int32 assembly/M/N::y@7
+        IL_0015:  call       int32 assembly/M/N::get_y()
+        IL_001a:  ldstr      "3"
+        IL_001f:  callvirt   instance int32 [runtime]System.String::get_Length()
+        IL_0024:  add
+        IL_0025:  stsfld     int32 assembly/M/N::z@8
+        IL_002a:  ret
+      } 
+
+      .property int32 y()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+        .get int32 assembly/M/N::get_y()
+      } 
+      .property int32 z()
+      {
+        .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+        .get int32 assembly/M/N::get_z()
+      } 
+    } 
+
+    .field static assembly int32 x@5
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .method public specialname static int32 get_x() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldsfld     int32 assembly/M::x@5
+      IL_0005:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldstr      "1"
+      IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_000a:  stsfld     int32 assembly/M::x@5
+      IL_000f:  call       void assembly/M/N::staticInitialization@()
+      IL_0014:  ret
+    } 
+
+    .property int32 x()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+      .get int32 assembly/M::get_x()
+    } 
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/M::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOff.il.net472.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOff.il.net472.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOff.il.net472.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOff.il.net472.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOff.il.netcore.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOff.il.netcore.release.bsl
similarity index 97%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOff.il.netcore.release.bsl
index f797cd82032..5dd4f4504a6 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.il.netcore.release.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOff.il.netcore.release.bsl
@@ -1,326 +1,326 @@
-
-
-
-
-
-.assembly extern runtime { }
-.assembly extern FSharp.Core { }
-.assembly extern netstandard
-{
-  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
-  .ver 2:1:0:0
-}
-.assembly assembly
-{
-  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
-                                                                                                      int32,
-                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
-
-  
-  
-
-  .hash algorithm 0x00008004
-  .ver 0:0:0:0
-}
-.mresource public FSharpSignatureData.assembly
-{
-  
-  
-}
-.mresource public FSharpOptimizationData.assembly
-{
-  
-  
-}
-.module assembly.exe
-
-.imagebase {value}
-.file alignment 0x00000200
-.stackreserve 0x00100000
-.subsystem 0x0003       
-.corflags 0x00000001    
-
-
-
-
-
-.class public abstract auto ansi sealed assembly
-       extends [runtime]System.Object
-{
-  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
-  .class sequential ansi serializable sealed nested public C
-         extends [runtime]System.ValueType
-         implements class [runtime]System.IEquatable`1<valuetype assembly/C>,
-                    [runtime]System.Collections.IStructuralEquatable,
-                    class [runtime]System.IComparable`1<valuetype assembly/C>,
-                    [runtime]System.IComparable,
-                    [runtime]System.Collections.IStructuralComparable
-  {
-    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
-    .field static assembly int32 x
-    .field static assembly int32 init@4
-    .field assembly valuetype [runtime]System.DateTime s
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(valuetype assembly/C obj) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  4
-      .locals init (valuetype assembly/C& V_0,
-               class [runtime]System.Collections.IComparer V_1)
-      IL_0000:  ldarga.s   obj
-      IL_0002:  stloc.0
-      IL_0003:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
-      IL_0008:  stloc.1
-      IL_0009:  ldarg.0
-      IL_000a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
-      IL_000f:  ldloc.0
-      IL_0010:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
-      IL_0015:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
-                                                                       valuetype [netstandard]System.DateTime)
-      IL_001a:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(object obj) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  8
-      IL_0000:  ldarg.0
-      IL_0001:  ldarg.1
-      IL_0002:  unbox.any  assembly/C
-      IL_0007:  call       instance int32 assembly/C::CompareTo(valuetype assembly/C)
-      IL_000c:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance int32  CompareTo(object obj,
-                                      class [runtime]System.Collections.IComparer comp) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  4
-      .locals init (valuetype assembly/C V_0,
-               valuetype assembly/C& V_1,
-               class [runtime]System.Collections.IComparer V_2)
-      IL_0000:  ldarg.1
-      IL_0001:  unbox.any  assembly/C
-      IL_0006:  stloc.0
-      IL_0007:  ldloca.s   V_0
-      IL_0009:  stloc.1
-      IL_000a:  ldarg.2
-      IL_000b:  stloc.2
-      IL_000c:  ldarg.0
-      IL_000d:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
-      IL_0012:  ldloc.1
-      IL_0013:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
-      IL_0018:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
-                                                                       valuetype [netstandard]System.DateTime)
-      IL_001d:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  7
-      .locals init (int32 V_0)
-      IL_0000:  ldc.i4.0
-      IL_0001:  stloc.0
-      IL_0002:  ldc.i4     0x9e3779b9
-      IL_0007:  ldarg.1
-      IL_0008:  ldarg.0
-      IL_0009:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
-      IL_000e:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericHashWithComparerIntrinsic<valuetype [runtime]System.DateTime>(class [runtime]System.Collections.IEqualityComparer,
-                                                                                                                                                                                !!0)
-      IL_0013:  ldloc.0
-      IL_0014:  ldc.i4.6
-      IL_0015:  shl
-      IL_0016:  ldloc.0
-      IL_0017:  ldc.i4.2
-      IL_0018:  shr
-      IL_0019:  add
-      IL_001a:  add
-      IL_001b:  add
-      IL_001c:  stloc.0
-      IL_001d:  ldloc.0
-      IL_001e:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance int32  GetHashCode() cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  8
-      IL_0000:  ldarg.0
-      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
-      IL_0006:  call       instance int32 assembly/C::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
-      IL_000b:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance bool  Equals(object obj,
-                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  4
-      .locals init (object V_0,
-               valuetype assembly/C V_1,
-               valuetype assembly/C& V_2,
-               class [runtime]System.Collections.IEqualityComparer V_3)
-      IL_0000:  ldarg.1
-      IL_0001:  stloc.0
-      IL_0002:  ldloc.0
-      IL_0003:  isinst     assembly/C
-      IL_0008:  ldnull
-      IL_0009:  cgt.un
-      IL_000b:  brfalse.s  IL_002b
-
-      IL_000d:  ldarg.1
-      IL_000e:  unbox.any  assembly/C
-      IL_0013:  stloc.1
-      IL_0014:  ldloca.s   V_1
-      IL_0016:  stloc.2
-      IL_0017:  ldarg.2
-      IL_0018:  stloc.3
-      IL_0019:  ldarg.0
-      IL_001a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
-      IL_001f:  ldloc.2
-      IL_0020:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
-      IL_0025:  call       bool [netstandard]System.DateTime::Equals(valuetype [netstandard]System.DateTime,
-                                                                     valuetype [netstandard]System.DateTime)
-      IL_002a:  ret
-
-      IL_002b:  ldc.i4.0
-      IL_002c:  ret
-    } 
-
-    .method public specialname rtspecialname 
-            instance void  .ctor(valuetype [runtime]System.DateTime s) cil managed
-    {
-      
-      .maxstack  8
-      IL_0000:  ldarg.0
-      IL_0001:  ldarg.1
-      IL_0002:  stfld      valuetype [runtime]System.DateTime assembly/C::s
-      IL_0007:  ret
-    } 
-
-    .method assembly static int32  f() cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  8
-      IL_0000:  nop
-      IL_0001:  volatile.
-      IL_0003:  ldsfld     int32 assembly/C::init@4
-      IL_0008:  ldc.i4.1
-      IL_0009:  bge.s      IL_0014
-
-      IL_000b:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
-      IL_0010:  nop
-      IL_0011:  nop
-      IL_0012:  br.s       IL_0015
-
-      IL_0014:  nop
-      IL_0015:  ldsfld     int32 assembly/C::x
-      IL_001a:  ldstr      "2"
-      IL_001f:  callvirt   instance int32 [runtime]System.String::get_Length()
-      IL_0024:  add
-      IL_0025:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance bool  Equals(valuetype assembly/C obj) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  4
-      .locals init (valuetype assembly/C& V_0)
-      IL_0000:  ldarga.s   obj
-      IL_0002:  stloc.0
-      IL_0003:  ldarg.0
-      IL_0004:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
-      IL_0009:  ldloc.0
-      IL_000a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
-      IL_000f:  call       bool [netstandard]System.DateTime::Equals(valuetype [netstandard]System.DateTime,
-                                                                     valuetype [netstandard]System.DateTime)
-      IL_0014:  ret
-    } 
-
-    .method public hidebysig virtual final 
-            instance bool  Equals(object obj) cil managed
-    {
-      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-      
-      .maxstack  4
-      .locals init (object V_0,
-               valuetype assembly/C V_1)
-      IL_0000:  ldarg.1
-      IL_0001:  stloc.0
-      IL_0002:  ldloc.0
-      IL_0003:  isinst     assembly/C
-      IL_0008:  ldnull
-      IL_0009:  cgt.un
-      IL_000b:  brfalse.s  IL_001c
-
-      IL_000d:  ldarg.1
-      IL_000e:  unbox.any  assembly/C
-      IL_0013:  stloc.1
-      IL_0014:  ldarg.0
-      IL_0015:  ldloc.1
-      IL_0016:  call       instance bool assembly/C::Equals(valuetype assembly/C)
-      IL_001b:  ret
-
-      IL_001c:  ldc.i4.0
-      IL_001d:  ret
-    } 
-
-    .method private specialname rtspecialname static 
-            void  .cctor() cil managed
-    {
-      
-      .maxstack  8
-      IL_0000:  ldc.i4.0
-      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
-      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
-      IL_000b:  pop
-      IL_000c:  ret
-    } 
-
-  } 
-
-} 
-
-.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
-       extends [runtime]System.Object
-{
-  .field static assembly int32 init@
-  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
-  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
-  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
-  .method public static void  main@() cil managed
-  {
-    .entrypoint
-    
-    .maxstack  8
-    IL_0000:  ldstr      "1"
-    IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
-    IL_000a:  stsfld     int32 assembly/C::x
-    IL_000f:  ldc.i4.1
-    IL_0010:  volatile.
-    IL_0012:  stsfld     int32 assembly/C::init@4
-    IL_0017:  ret
-  } 
-
-} 
-
-
-
-
-
-
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class sequential ansi serializable sealed nested public C
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype assembly/C>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype assembly/C>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field static assembly int32 x
+    .field static assembly int32 init@4
+    .field assembly valuetype [runtime]System.DateTime s
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(valuetype assembly/C obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/C& V_0,
+               class [runtime]System.Collections.IComparer V_1)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0008:  stloc.1
+      IL_0009:  ldarg.0
+      IL_000a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_000f:  ldloc.0
+      IL_0010:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0015:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_001a:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  assembly/C
+      IL_0007:  call       instance int32 assembly/C::CompareTo(valuetype assembly/C)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/C V_0,
+               valuetype assembly/C& V_1,
+               class [runtime]System.Collections.IComparer V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  assembly/C
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldarg.2
+      IL_000b:  stloc.2
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0018:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_001d:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldc.i4.0
+      IL_0001:  stloc.0
+      IL_0002:  ldc.i4     0x9e3779b9
+      IL_0007:  ldarg.1
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_000e:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericHashWithComparerIntrinsic<valuetype [runtime]System.DateTime>(class [runtime]System.Collections.IEqualityComparer,
+                                                                                                                                                                                !!0)
+      IL_0013:  ldloc.0
+      IL_0014:  ldc.i4.6
+      IL_0015:  shl
+      IL_0016:  ldloc.0
+      IL_0017:  ldc.i4.2
+      IL_0018:  shr
+      IL_0019:  add
+      IL_001a:  add
+      IL_001b:  add
+      IL_001c:  stloc.0
+      IL_001d:  ldloc.0
+      IL_001e:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 assembly/C::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype assembly/C V_1,
+               valuetype assembly/C& V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     assembly/C
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_002b
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  assembly/C
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldarg.2
+      IL_0018:  stloc.3
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_001f:  ldloc.2
+      IL_0020:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0025:  call       bool [netstandard]System.DateTime::Equals(valuetype [netstandard]System.DateTime,
+                                                                     valuetype [netstandard]System.DateTime)
+      IL_002a:  ret
+
+      IL_002b:  ldc.i4.0
+      IL_002c:  ret
+    } 
+
+    .method public specialname rtspecialname 
+            instance void  .ctor(valuetype [runtime]System.DateTime s) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0007:  ret
+    } 
+
+    .method assembly static int32  f() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  nop
+      IL_0001:  volatile.
+      IL_0003:  ldsfld     int32 assembly/C::init@4
+      IL_0008:  ldc.i4.1
+      IL_0009:  bge.s      IL_0014
+
+      IL_000b:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_0010:  nop
+      IL_0011:  nop
+      IL_0012:  br.s       IL_0015
+
+      IL_0014:  nop
+      IL_0015:  ldsfld     int32 assembly/C::x
+      IL_001a:  ldstr      "2"
+      IL_001f:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0024:  add
+      IL_0025:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(valuetype assembly/C obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/C& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldarg.0
+      IL_0004:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0009:  ldloc.0
+      IL_000a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_000f:  call       bool [netstandard]System.DateTime::Equals(valuetype [netstandard]System.DateTime,
+                                                                     valuetype [netstandard]System.DateTime)
+      IL_0014:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype assembly/C V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     assembly/C
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  assembly/C
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool assembly/C::Equals(valuetype assembly/C)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+    .method private specialname rtspecialname static 
+            void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ldstr      "1"
+    IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
+    IL_000a:  stsfld     int32 assembly/C::x
+    IL_000f:  ldc.i4.1
+    IL_0010:  volatile.
+    IL_0012:  stsfld     int32 assembly/C::init@4
+    IL_0017:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOn.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOn.il.net472.debug.bsl
new file mode 100644
index 00000000000..b533fbc20e4
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOn.il.net472.debug.bsl
@@ -0,0 +1,372 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class sequential ansi serializable sealed nested public C
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype assembly/C>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype assembly/C>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field static assembly int32 x
+    .field static assembly int32 init@4
+    .field assembly valuetype [runtime]System.DateTime s
+    .method public hidebysig virtual final instance int32  CompareTo(valuetype assembly/C obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/C& V_0,
+               class [runtime]System.Collections.IComparer V_1,
+               valuetype [runtime]System.DateTime V_2,
+               valuetype [runtime]System.DateTime V_3,
+               class [runtime]System.Collections.IComparer V_4)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0008:  stloc.1
+      IL_0009:  ldarg.0
+      IL_000a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_000f:  stloc.2
+      IL_0010:  ldloc.0
+      IL_0011:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0016:  stloc.3
+      IL_0017:  ldloc.1
+      IL_0018:  stloc.s    V_4
+      IL_001a:  ldloc.2
+      IL_001b:  ldloc.3
+      IL_001c:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_0021:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  assembly/C
+      IL_0007:  call       instance int32 assembly/C::CompareTo(valuetype assembly/C)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/C V_0,
+               valuetype assembly/C& V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               valuetype [runtime]System.DateTime V_3,
+               valuetype [runtime]System.DateTime V_4,
+               class [runtime]System.Collections.IComparer V_5)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  assembly/C
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldarg.2
+      IL_000b:  stloc.2
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0012:  stloc.3
+      IL_0013:  ldloc.1
+      IL_0014:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0019:  stloc.s    V_4
+      IL_001b:  ldloc.2
+      IL_001c:  stloc.s    V_5
+      IL_001e:  ldloc.3
+      IL_001f:  ldloc.s    V_4
+      IL_0021:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_0026:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldc.i4.0
+      IL_0001:  stloc.0
+      IL_0002:  ldc.i4     0x9e3779b9
+      IL_0007:  ldarg.1
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_000e:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericHashWithComparerIntrinsic<valuetype [runtime]System.DateTime>(class [runtime]System.Collections.IEqualityComparer,
+                                                                                                                                                                          !!0)
+      IL_0013:  ldloc.0
+      IL_0014:  ldc.i4.6
+      IL_0015:  shl
+      IL_0016:  ldloc.0
+      IL_0017:  ldc.i4.2
+      IL_0018:  shr
+      IL_0019:  add
+      IL_001a:  add
+      IL_001b:  add
+      IL_001c:  stloc.0
+      IL_001d:  ldloc.0
+      IL_001e:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 assembly/C::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype assembly/C V_1,
+               valuetype assembly/C& V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3,
+               valuetype [runtime]System.DateTime V_4,
+               valuetype [runtime]System.DateTime V_5,
+               class [runtime]System.Collections.IEqualityComparer V_6)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     assembly/C
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_0036
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  assembly/C
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldarg.2
+      IL_0018:  stloc.3
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.2
+      IL_0022:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0027:  stloc.s    V_5
+      IL_0029:  ldloc.3
+      IL_002a:  stloc.s    V_6
+      IL_002c:  ldloc.s    V_4
+      IL_002e:  ldloc.s    V_5
+      IL_0030:  call       bool [netstandard]System.DateTime::Equals(valuetype [netstandard]System.DateTime,
+                                                                     valuetype [netstandard]System.DateTime)
+      IL_0035:  ret
+
+      IL_0036:  ldc.i4.0
+      IL_0037:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor(valuetype [runtime]System.DateTime s) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0007:  ret
+    } 
+
+    .method assembly static int32  f() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  nop
+      IL_0001:  volatile.
+      IL_0003:  ldsfld     int32 assembly/C::init@4
+      IL_0008:  ldc.i4.1
+      IL_0009:  bge.s      IL_0014
+
+      IL_000b:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_0010:  nop
+      IL_0011:  nop
+      IL_0012:  br.s       IL_0015
+
+      IL_0014:  nop
+      IL_0015:  ldsfld     int32 assembly/C::x
+      IL_001a:  ldstr      "2"
+      IL_001f:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0024:  add
+      IL_0025:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(valuetype assembly/C obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/C& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldarg.0
+      IL_0004:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0009:  ldloc.0
+      IL_000a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_000f:  call       bool [netstandard]System.DateTime::Equals(valuetype [netstandard]System.DateTime,
+                                                                     valuetype [netstandard]System.DateTime)
+      IL_0014:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype assembly/C V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     assembly/C
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  assembly/C
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool assembly/C::Equals(valuetype assembly/C)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldstr      "1"
+      IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_000a:  stsfld     int32 assembly/C::x
+      IL_000f:  ldc.i4.1
+      IL_0010:  volatile.
+      IL_0012:  stsfld     int32 assembly/C::init@4
+      IL_0017:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/C::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOn.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOn.il.net472.release.bsl
new file mode 100644
index 00000000000..029cf56bad8
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOn.il.net472.release.bsl
@@ -0,0 +1,345 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class sequential ansi serializable sealed nested public C
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype assembly/C>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype assembly/C>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field static assembly int32 x
+    .field static assembly int32 init@4
+    .field assembly valuetype [runtime]System.DateTime s
+    .method public hidebysig virtual final instance int32  CompareTo(valuetype assembly/C obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/C& V_0,
+               class [runtime]System.Collections.IComparer V_1)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0008:  stloc.1
+      IL_0009:  ldarg.0
+      IL_000a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_000f:  ldloc.0
+      IL_0010:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0015:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_001a:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  assembly/C
+      IL_0007:  call       instance int32 assembly/C::CompareTo(valuetype assembly/C)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/C V_0,
+               valuetype assembly/C& V_1,
+               class [runtime]System.Collections.IComparer V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  assembly/C
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldarg.2
+      IL_000b:  stloc.2
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0018:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_001d:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldc.i4.0
+      IL_0001:  stloc.0
+      IL_0002:  ldc.i4     0x9e3779b9
+      IL_0007:  ldarg.1
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_000e:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericHashWithComparerIntrinsic<valuetype [runtime]System.DateTime>(class [runtime]System.Collections.IEqualityComparer,
+                                                                                                                                                                          !!0)
+      IL_0013:  ldloc.0
+      IL_0014:  ldc.i4.6
+      IL_0015:  shl
+      IL_0016:  ldloc.0
+      IL_0017:  ldc.i4.2
+      IL_0018:  shr
+      IL_0019:  add
+      IL_001a:  add
+      IL_001b:  add
+      IL_001c:  stloc.0
+      IL_001d:  ldloc.0
+      IL_001e:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 assembly/C::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype assembly/C V_1,
+               valuetype assembly/C& V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     assembly/C
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_002b
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  assembly/C
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldarg.2
+      IL_0018:  stloc.3
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_001f:  ldloc.2
+      IL_0020:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0025:  call       bool [netstandard]System.DateTime::Equals(valuetype [netstandard]System.DateTime,
+                                                                     valuetype [netstandard]System.DateTime)
+      IL_002a:  ret
+
+      IL_002b:  ldc.i4.0
+      IL_002c:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor(valuetype [runtime]System.DateTime s) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0007:  ret
+    } 
+
+    .method assembly static int32  f() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  nop
+      IL_0001:  volatile.
+      IL_0003:  ldsfld     int32 assembly/C::init@4
+      IL_0008:  ldc.i4.1
+      IL_0009:  bge.s      IL_0014
+
+      IL_000b:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_0010:  nop
+      IL_0011:  nop
+      IL_0012:  br.s       IL_0015
+
+      IL_0014:  nop
+      IL_0015:  ldsfld     int32 assembly/C::x
+      IL_001a:  ldstr      "2"
+      IL_001f:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0024:  add
+      IL_0025:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(valuetype assembly/C obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/C& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldarg.0
+      IL_0004:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0009:  ldloc.0
+      IL_000a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_000f:  call       bool [netstandard]System.DateTime::Equals(valuetype [netstandard]System.DateTime,
+                                                                     valuetype [netstandard]System.DateTime)
+      IL_0014:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype assembly/C V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     assembly/C
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  assembly/C
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool assembly/C::Equals(valuetype assembly/C)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldstr      "1"
+      IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_000a:  stsfld     int32 assembly/C::x
+      IL_000f:  ldc.i4.1
+      IL_0010:  volatile.
+      IL_0012:  stsfld     int32 assembly/C::init@4
+      IL_0017:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/C::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOn.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
new file mode 100644
index 00000000000..89fbc9a2786
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOn.il.netcore.debug.bsl
@@ -0,0 +1,372 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class sequential ansi serializable sealed nested public C
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype assembly/C>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype assembly/C>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field static assembly int32 x
+    .field static assembly int32 init@4
+    .field assembly valuetype [runtime]System.DateTime s
+    .method public hidebysig virtual final instance int32  CompareTo(valuetype assembly/C obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/C& V_0,
+               class [runtime]System.Collections.IComparer V_1,
+               valuetype [runtime]System.DateTime V_2,
+               valuetype [runtime]System.DateTime V_3,
+               class [runtime]System.Collections.IComparer V_4)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0008:  stloc.1
+      IL_0009:  ldarg.0
+      IL_000a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_000f:  stloc.2
+      IL_0010:  ldloc.0
+      IL_0011:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0016:  stloc.3
+      IL_0017:  ldloc.1
+      IL_0018:  stloc.s    V_4
+      IL_001a:  ldloc.2
+      IL_001b:  ldloc.3
+      IL_001c:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_0021:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  assembly/C
+      IL_0007:  call       instance int32 assembly/C::CompareTo(valuetype assembly/C)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/C V_0,
+               valuetype assembly/C& V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               valuetype [runtime]System.DateTime V_3,
+               valuetype [runtime]System.DateTime V_4,
+               class [runtime]System.Collections.IComparer V_5)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  assembly/C
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldarg.2
+      IL_000b:  stloc.2
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0012:  stloc.3
+      IL_0013:  ldloc.1
+      IL_0014:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0019:  stloc.s    V_4
+      IL_001b:  ldloc.2
+      IL_001c:  stloc.s    V_5
+      IL_001e:  ldloc.3
+      IL_001f:  ldloc.s    V_4
+      IL_0021:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_0026:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldc.i4.0
+      IL_0001:  stloc.0
+      IL_0002:  ldc.i4     0x9e3779b9
+      IL_0007:  ldarg.1
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_000e:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericHashWithComparerIntrinsic<valuetype [runtime]System.DateTime>(class [runtime]System.Collections.IEqualityComparer,
+                                                                                                                                                                                !!0)
+      IL_0013:  ldloc.0
+      IL_0014:  ldc.i4.6
+      IL_0015:  shl
+      IL_0016:  ldloc.0
+      IL_0017:  ldc.i4.2
+      IL_0018:  shr
+      IL_0019:  add
+      IL_001a:  add
+      IL_001b:  add
+      IL_001c:  stloc.0
+      IL_001d:  ldloc.0
+      IL_001e:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 assembly/C::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype assembly/C V_1,
+               valuetype assembly/C& V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3,
+               valuetype [runtime]System.DateTime V_4,
+               valuetype [runtime]System.DateTime V_5,
+               class [runtime]System.Collections.IEqualityComparer V_6)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     assembly/C
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_0036
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  assembly/C
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldarg.2
+      IL_0018:  stloc.3
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.2
+      IL_0022:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0027:  stloc.s    V_5
+      IL_0029:  ldloc.3
+      IL_002a:  stloc.s    V_6
+      IL_002c:  ldloc.s    V_4
+      IL_002e:  ldloc.s    V_5
+      IL_0030:  call       bool [netstandard]System.DateTime::Equals(valuetype [netstandard]System.DateTime,
+                                                                     valuetype [netstandard]System.DateTime)
+      IL_0035:  ret
+
+      IL_0036:  ldc.i4.0
+      IL_0037:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor(valuetype [runtime]System.DateTime s) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0007:  ret
+    } 
+
+    .method assembly static int32  f() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  nop
+      IL_0001:  volatile.
+      IL_0003:  ldsfld     int32 assembly/C::init@4
+      IL_0008:  ldc.i4.1
+      IL_0009:  bge.s      IL_0014
+
+      IL_000b:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_0010:  nop
+      IL_0011:  nop
+      IL_0012:  br.s       IL_0015
+
+      IL_0014:  nop
+      IL_0015:  ldsfld     int32 assembly/C::x
+      IL_001a:  ldstr      "2"
+      IL_001f:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0024:  add
+      IL_0025:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(valuetype assembly/C obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/C& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldarg.0
+      IL_0004:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0009:  ldloc.0
+      IL_000a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_000f:  call       bool [netstandard]System.DateTime::Equals(valuetype [netstandard]System.DateTime,
+                                                                     valuetype [netstandard]System.DateTime)
+      IL_0014:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype assembly/C V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     assembly/C
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  assembly/C
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool assembly/C::Equals(valuetype assembly/C)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldstr      "1"
+      IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_000a:  stsfld     int32 assembly/C::x
+      IL_000f:  ldc.i4.1
+      IL_0010:  volatile.
+      IL_0012:  stsfld     int32 assembly/C::init@4
+      IL_0017:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/C::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOn.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOn.il.netcore.release.bsl
new file mode 100644
index 00000000000..19c8b0f37a8
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/StaticInit/StaticInit_Struct01.fs.RealInternalSignatureOn.il.netcore.release.bsl
@@ -0,0 +1,345 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class sequential ansi serializable sealed nested public C
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype assembly/C>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype assembly/C>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field static assembly int32 x
+    .field static assembly int32 init@4
+    .field assembly valuetype [runtime]System.DateTime s
+    .method public hidebysig virtual final instance int32  CompareTo(valuetype assembly/C obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/C& V_0,
+               class [runtime]System.Collections.IComparer V_1)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0008:  stloc.1
+      IL_0009:  ldarg.0
+      IL_000a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_000f:  ldloc.0
+      IL_0010:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0015:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_001a:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  assembly/C
+      IL_0007:  call       instance int32 assembly/C::CompareTo(valuetype assembly/C)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/C V_0,
+               valuetype assembly/C& V_1,
+               class [runtime]System.Collections.IComparer V_2)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  assembly/C
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldarg.2
+      IL_000b:  stloc.2
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0012:  ldloc.1
+      IL_0013:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0018:  call       int32 [netstandard]System.DateTime::Compare(valuetype [netstandard]System.DateTime,
+                                                                       valuetype [netstandard]System.DateTime)
+      IL_001d:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldc.i4.0
+      IL_0001:  stloc.0
+      IL_0002:  ldc.i4     0x9e3779b9
+      IL_0007:  ldarg.1
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_000e:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericHashWithComparerIntrinsic<valuetype [runtime]System.DateTime>(class [runtime]System.Collections.IEqualityComparer,
+                                                                                                                                                                                !!0)
+      IL_0013:  ldloc.0
+      IL_0014:  ldc.i4.6
+      IL_0015:  shl
+      IL_0016:  ldloc.0
+      IL_0017:  ldc.i4.2
+      IL_0018:  shr
+      IL_0019:  add
+      IL_001a:  add
+      IL_001b:  add
+      IL_001c:  stloc.0
+      IL_001d:  ldloc.0
+      IL_001e:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 assembly/C::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype assembly/C V_1,
+               valuetype assembly/C& V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     assembly/C
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_002b
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  assembly/C
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldarg.2
+      IL_0018:  stloc.3
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_001f:  ldloc.2
+      IL_0020:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0025:  call       bool [netstandard]System.DateTime::Equals(valuetype [netstandard]System.DateTime,
+                                                                     valuetype [netstandard]System.DateTime)
+      IL_002a:  ret
+
+      IL_002b:  ldc.i4.0
+      IL_002c:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor(valuetype [runtime]System.DateTime s) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0007:  ret
+    } 
+
+    .method assembly static int32  f() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  nop
+      IL_0001:  volatile.
+      IL_0003:  ldsfld     int32 assembly/C::init@4
+      IL_0008:  ldc.i4.1
+      IL_0009:  bge.s      IL_0014
+
+      IL_000b:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_0010:  nop
+      IL_0011:  nop
+      IL_0012:  br.s       IL_0015
+
+      IL_0014:  nop
+      IL_0015:  ldsfld     int32 assembly/C::x
+      IL_001a:  ldstr      "2"
+      IL_001f:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0024:  add
+      IL_0025:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(valuetype assembly/C obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype assembly/C& V_0)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldarg.0
+      IL_0004:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_0009:  ldloc.0
+      IL_000a:  ldfld      valuetype [runtime]System.DateTime assembly/C::s
+      IL_000f:  call       bool [netstandard]System.DateTime::Equals(valuetype [netstandard]System.DateTime,
+                                                                     valuetype [netstandard]System.DateTime)
+      IL_0014:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype assembly/C V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     assembly/C
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  assembly/C
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool assembly/C::Equals(valuetype assembly/C)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldstr      "1"
+      IL_0005:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_000a:  stsfld     int32 assembly/C::x
+      IL_000f:  ldc.i4.1
+      IL_0010:  volatile.
+      IL_0012:  stsfld     int32 assembly/C::init@4
+      IL_0017:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/C::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles_1.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles_1.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles.fs.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles_1.fs.il.debug.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles.fs.il.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles_1.fs.il.debug.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles.fs.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles_1.fs.il.release.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles.fs.il.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles_1.fs.il.release.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles_2.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles_2.fs
new file mode 100644
index 00000000000..01e8d833c73
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles_2.fs
@@ -0,0 +1,39 @@
+// ===========================================================================================================================
+//  Test case for GenericEqualityERFast with floats/doubles
+//  Ensures that matrix of values evaluate to the same values as the shipping compiler
+// ===========================================================================================================================
+module floatsanddoubles
+
+open System
+open System
+
+type Float =
+    struct
+        val F : float
+        new (f:float) = { F = f }
+    end
+
+type Double =
+    struct
+        val D : double
+        new (d:double) = { D = d }
+    end
+
+let floats  = [| Float(Double.Epsilon); Float(Double.MinValue); Float(Double.MaxValue);Float(Double.NegativeInfinity);Float(Double.PositiveInfinity);Float(Double.NaN); Float(7.1)|]
+let doubles = [| Double(Double.Epsilon); Double(Double.MinValue); Double(Double.MaxValue);Double(Double.NegativeInfinity);Double(Double.PositiveInfinity);Double(Double.NaN); Double(8.1)|]
+let names = [| "Epsilon"; "MinValue"; "MaxValue";"NegativeInfinity";"PositiveInfinity";"NaN";"Number" |]
+
+[<EntryPoint>]
+let main argv =
+
+    for i in 0 .. doubles.Length - 1  do
+        for j in 0 .. doubles.Length - 1 do
+            printfn "Doubles:   %-17s = %-17s  is:  %-5b   Values %f = %f" (names.[i]) (names.[j]) (doubles.[i].Equals(doubles.[j])) (doubles.[i].D) (doubles.[j].D)
+        printfn ""
+
+    for i in 0 .. floats.Length - 1  do
+        for j in 0 .. floats.Length - 1 do
+            printfn "Floats:    %-17s = %-17s  is:  %-5b   Values %f = %f" (names.[i]) (names.[j]) (floats.[i].Equals(floats.[j])) (floats.[i].F) (floats.[j].F)
+        printfn ""
+
+    0 // return an integer exit code
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles_2.fs.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles_2.fs.il.debug.bsl
new file mode 100644
index 00000000000..eaa9b097b91
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles_2.fs.il.debug.bsl
@@ -0,0 +1,1449 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed floatsanddoubles
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class sequential ansi serializable sealed nested public Float
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype floatsanddoubles/Float>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype floatsanddoubles/Float>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly float64 F@
+    .method public hidebysig specialname instance float64  get_F() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.IsReadOnlyAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(valuetype floatsanddoubles/Float obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (valuetype floatsanddoubles/Float& V_0,
+               class [runtime]System.Collections.IComparer V_1,
+               float64 V_2,
+               float64 V_3,
+               class [runtime]System.Collections.IComparer V_4,
+               float64 V_5,
+               float64 V_6)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0008:  stloc.1
+      IL_0009:  ldarg.0
+      IL_000a:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_000f:  stloc.2
+      IL_0010:  ldloc.0
+      IL_0011:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_0016:  stloc.3
+      IL_0017:  ldloc.1
+      IL_0018:  stloc.s    V_4
+      IL_001a:  ldloc.2
+      IL_001b:  stloc.s    V_5
+      IL_001d:  ldloc.3
+      IL_001e:  stloc.s    V_6
+      IL_0020:  ldloc.s    V_5
+      IL_0022:  ldloc.s    V_6
+      IL_0024:  clt
+      IL_0026:  brfalse.s  IL_002a
+
+      IL_0028:  ldc.i4.m1
+      IL_0029:  ret
+
+      IL_002a:  ldloc.s    V_5
+      IL_002c:  ldloc.s    V_6
+      IL_002e:  cgt
+      IL_0030:  brfalse.s  IL_0034
+
+      IL_0032:  ldc.i4.1
+      IL_0033:  ret
+
+      IL_0034:  ldloc.s    V_5
+      IL_0036:  ldloc.s    V_6
+      IL_0038:  ceq
+      IL_003a:  brfalse.s  IL_003e
+
+      IL_003c:  ldc.i4.0
+      IL_003d:  ret
+
+      IL_003e:  ldloc.s    V_4
+      IL_0040:  ldloc.s    V_5
+      IL_0042:  ldloc.s    V_6
+      IL_0044:  tail.
+      IL_0046:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericComparisonWithComparerIntrinsic<float64>(class [runtime]System.Collections.IComparer,
+                                                                                                                                                    !!0,
+                                                                                                                                                    !!0)
+      IL_004b:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  floatsanddoubles/Float
+      IL_0007:  call       instance int32 floatsanddoubles/Float::CompareTo(valuetype floatsanddoubles/Float)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (valuetype floatsanddoubles/Float V_0,
+               valuetype floatsanddoubles/Float& V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               float64 V_3,
+               float64 V_4,
+               class [runtime]System.Collections.IComparer V_5,
+               float64 V_6,
+               float64 V_7)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  floatsanddoubles/Float
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldarg.2
+      IL_000b:  stloc.2
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_0012:  stloc.3
+      IL_0013:  ldloc.1
+      IL_0014:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_0019:  stloc.s    V_4
+      IL_001b:  ldloc.2
+      IL_001c:  stloc.s    V_5
+      IL_001e:  ldloc.3
+      IL_001f:  stloc.s    V_6
+      IL_0021:  ldloc.s    V_4
+      IL_0023:  stloc.s    V_7
+      IL_0025:  ldloc.s    V_6
+      IL_0027:  ldloc.s    V_7
+      IL_0029:  clt
+      IL_002b:  brfalse.s  IL_002f
+
+      IL_002d:  ldc.i4.m1
+      IL_002e:  ret
+
+      IL_002f:  ldloc.s    V_6
+      IL_0031:  ldloc.s    V_7
+      IL_0033:  cgt
+      IL_0035:  brfalse.s  IL_0039
+
+      IL_0037:  ldc.i4.1
+      IL_0038:  ret
+
+      IL_0039:  ldloc.s    V_6
+      IL_003b:  ldloc.s    V_7
+      IL_003d:  ceq
+      IL_003f:  brfalse.s  IL_0043
+
+      IL_0041:  ldc.i4.0
+      IL_0042:  ret
+
+      IL_0043:  ldloc.s    V_5
+      IL_0045:  ldloc.s    V_6
+      IL_0047:  ldloc.s    V_7
+      IL_0049:  tail.
+      IL_004b:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericComparisonWithComparerIntrinsic<float64>(class [runtime]System.Collections.IComparer,
+                                                                                                                                                    !!0,
+                                                                                                                                                    !!0)
+      IL_0050:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldc.i4.0
+      IL_0001:  stloc.0
+      IL_0002:  ldc.i4     0x9e3779b9
+      IL_0007:  ldarg.1
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_000e:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericHashWithComparerIntrinsic<float64>(class [runtime]System.Collections.IEqualityComparer,
+                                                                                                                                              !!0)
+      IL_0013:  ldloc.0
+      IL_0014:  ldc.i4.6
+      IL_0015:  shl
+      IL_0016:  ldloc.0
+      IL_0017:  ldc.i4.2
+      IL_0018:  shr
+      IL_0019:  add
+      IL_001a:  add
+      IL_001b:  add
+      IL_001c:  stloc.0
+      IL_001d:  ldloc.0
+      IL_001e:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 floatsanddoubles/Float::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype floatsanddoubles/Float V_1,
+               valuetype floatsanddoubles/Float& V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3,
+               float64 V_4,
+               float64 V_5,
+               class [runtime]System.Collections.IEqualityComparer V_6)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     floatsanddoubles/Float
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_0033
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  floatsanddoubles/Float
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldarg.2
+      IL_0018:  stloc.3
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.2
+      IL_0022:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_0027:  stloc.s    V_5
+      IL_0029:  ldloc.3
+      IL_002a:  stloc.s    V_6
+      IL_002c:  ldloc.s    V_4
+      IL_002e:  ldloc.s    V_5
+      IL_0030:  ceq
+      IL_0032:  ret
+
+      IL_0033:  ldc.i4.0
+      IL_0034:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor(float64 f) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      float64 floatsanddoubles/Float::F@
+      IL_0007:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(valuetype floatsanddoubles/Float obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype floatsanddoubles/Float& V_0,
+               float64 V_1,
+               float64 V_2,
+               float64 V_3,
+               float64 V_4)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldarg.0
+      IL_0004:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_0009:  stloc.1
+      IL_000a:  ldloc.0
+      IL_000b:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.1
+      IL_0012:  stloc.3
+      IL_0013:  ldloc.2
+      IL_0014:  stloc.s    V_4
+      IL_0016:  ldloc.3
+      IL_0017:  ldloc.s    V_4
+      IL_0019:  ceq
+      IL_001b:  brfalse.s  IL_001f
+
+      IL_001d:  ldc.i4.1
+      IL_001e:  ret
+
+      IL_001f:  ldloc.3
+      IL_0020:  ldloc.3
+      IL_0021:  beq.s      IL_002d
+
+      IL_0023:  ldloc.s    V_4
+      IL_0025:  ldloc.s    V_4
+      IL_0027:  ceq
+      IL_0029:  ldc.i4.0
+      IL_002a:  ceq
+      IL_002c:  ret
+
+      IL_002d:  ldc.i4.0
+      IL_002e:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype floatsanddoubles/Float V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     floatsanddoubles/Float
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  floatsanddoubles/Float
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool floatsanddoubles/Float::Equals(valuetype floatsanddoubles/Float)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+    .property instance float64 F()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance float64 floatsanddoubles/Float::get_F()
+    } 
+  } 
+
+  .class sequential ansi serializable sealed nested public Double
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype floatsanddoubles/Double>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype floatsanddoubles/Double>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly float64 D@
+    .method public hidebysig specialname instance float64  get_D() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.IsReadOnlyAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(valuetype floatsanddoubles/Double obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (valuetype floatsanddoubles/Double& V_0,
+               class [runtime]System.Collections.IComparer V_1,
+               float64 V_2,
+               float64 V_3,
+               class [runtime]System.Collections.IComparer V_4,
+               float64 V_5,
+               float64 V_6)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0008:  stloc.1
+      IL_0009:  ldarg.0
+      IL_000a:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_000f:  stloc.2
+      IL_0010:  ldloc.0
+      IL_0011:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_0016:  stloc.3
+      IL_0017:  ldloc.1
+      IL_0018:  stloc.s    V_4
+      IL_001a:  ldloc.2
+      IL_001b:  stloc.s    V_5
+      IL_001d:  ldloc.3
+      IL_001e:  stloc.s    V_6
+      IL_0020:  ldloc.s    V_5
+      IL_0022:  ldloc.s    V_6
+      IL_0024:  clt
+      IL_0026:  brfalse.s  IL_002a
+
+      IL_0028:  ldc.i4.m1
+      IL_0029:  ret
+
+      IL_002a:  ldloc.s    V_5
+      IL_002c:  ldloc.s    V_6
+      IL_002e:  cgt
+      IL_0030:  brfalse.s  IL_0034
+
+      IL_0032:  ldc.i4.1
+      IL_0033:  ret
+
+      IL_0034:  ldloc.s    V_5
+      IL_0036:  ldloc.s    V_6
+      IL_0038:  ceq
+      IL_003a:  brfalse.s  IL_003e
+
+      IL_003c:  ldc.i4.0
+      IL_003d:  ret
+
+      IL_003e:  ldloc.s    V_4
+      IL_0040:  ldloc.s    V_5
+      IL_0042:  ldloc.s    V_6
+      IL_0044:  tail.
+      IL_0046:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericComparisonWithComparerIntrinsic<float64>(class [runtime]System.Collections.IComparer,
+                                                                                                                                                    !!0,
+                                                                                                                                                    !!0)
+      IL_004b:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  floatsanddoubles/Double
+      IL_0007:  call       instance int32 floatsanddoubles/Double::CompareTo(valuetype floatsanddoubles/Double)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (valuetype floatsanddoubles/Double V_0,
+               valuetype floatsanddoubles/Double& V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               float64 V_3,
+               float64 V_4,
+               class [runtime]System.Collections.IComparer V_5,
+               float64 V_6,
+               float64 V_7)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  floatsanddoubles/Double
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldarg.2
+      IL_000b:  stloc.2
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_0012:  stloc.3
+      IL_0013:  ldloc.1
+      IL_0014:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_0019:  stloc.s    V_4
+      IL_001b:  ldloc.2
+      IL_001c:  stloc.s    V_5
+      IL_001e:  ldloc.3
+      IL_001f:  stloc.s    V_6
+      IL_0021:  ldloc.s    V_4
+      IL_0023:  stloc.s    V_7
+      IL_0025:  ldloc.s    V_6
+      IL_0027:  ldloc.s    V_7
+      IL_0029:  clt
+      IL_002b:  brfalse.s  IL_002f
+
+      IL_002d:  ldc.i4.m1
+      IL_002e:  ret
+
+      IL_002f:  ldloc.s    V_6
+      IL_0031:  ldloc.s    V_7
+      IL_0033:  cgt
+      IL_0035:  brfalse.s  IL_0039
+
+      IL_0037:  ldc.i4.1
+      IL_0038:  ret
+
+      IL_0039:  ldloc.s    V_6
+      IL_003b:  ldloc.s    V_7
+      IL_003d:  ceq
+      IL_003f:  brfalse.s  IL_0043
+
+      IL_0041:  ldc.i4.0
+      IL_0042:  ret
+
+      IL_0043:  ldloc.s    V_5
+      IL_0045:  ldloc.s    V_6
+      IL_0047:  ldloc.s    V_7
+      IL_0049:  tail.
+      IL_004b:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericComparisonWithComparerIntrinsic<float64>(class [runtime]System.Collections.IComparer,
+                                                                                                                                                    !!0,
+                                                                                                                                                    !!0)
+      IL_0050:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldc.i4.0
+      IL_0001:  stloc.0
+      IL_0002:  ldc.i4     0x9e3779b9
+      IL_0007:  ldarg.1
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_000e:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericHashWithComparerIntrinsic<float64>(class [runtime]System.Collections.IEqualityComparer,
+                                                                                                                                              !!0)
+      IL_0013:  ldloc.0
+      IL_0014:  ldc.i4.6
+      IL_0015:  shl
+      IL_0016:  ldloc.0
+      IL_0017:  ldc.i4.2
+      IL_0018:  shr
+      IL_0019:  add
+      IL_001a:  add
+      IL_001b:  add
+      IL_001c:  stloc.0
+      IL_001d:  ldloc.0
+      IL_001e:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 floatsanddoubles/Double::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype floatsanddoubles/Double V_1,
+               valuetype floatsanddoubles/Double& V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3,
+               float64 V_4,
+               float64 V_5,
+               class [runtime]System.Collections.IEqualityComparer V_6)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     floatsanddoubles/Double
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_0033
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  floatsanddoubles/Double
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldarg.2
+      IL_0018:  stloc.3
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_001f:  stloc.s    V_4
+      IL_0021:  ldloc.2
+      IL_0022:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_0027:  stloc.s    V_5
+      IL_0029:  ldloc.3
+      IL_002a:  stloc.s    V_6
+      IL_002c:  ldloc.s    V_4
+      IL_002e:  ldloc.s    V_5
+      IL_0030:  ceq
+      IL_0032:  ret
+
+      IL_0033:  ldc.i4.0
+      IL_0034:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor(float64 d) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      float64 floatsanddoubles/Double::D@
+      IL_0007:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(valuetype floatsanddoubles/Double obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype floatsanddoubles/Double& V_0,
+               float64 V_1,
+               float64 V_2,
+               float64 V_3,
+               float64 V_4)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldarg.0
+      IL_0004:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_0009:  stloc.1
+      IL_000a:  ldloc.0
+      IL_000b:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.1
+      IL_0012:  stloc.3
+      IL_0013:  ldloc.2
+      IL_0014:  stloc.s    V_4
+      IL_0016:  ldloc.3
+      IL_0017:  ldloc.s    V_4
+      IL_0019:  ceq
+      IL_001b:  brfalse.s  IL_001f
+
+      IL_001d:  ldc.i4.1
+      IL_001e:  ret
+
+      IL_001f:  ldloc.3
+      IL_0020:  ldloc.3
+      IL_0021:  beq.s      IL_002d
+
+      IL_0023:  ldloc.s    V_4
+      IL_0025:  ldloc.s    V_4
+      IL_0027:  ceq
+      IL_0029:  ldc.i4.0
+      IL_002a:  ceq
+      IL_002c:  ret
+
+      IL_002d:  ldc.i4.0
+      IL_002e:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype floatsanddoubles/Double V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     floatsanddoubles/Double
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  floatsanddoubles/Double
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool floatsanddoubles/Double::Equals(valuetype floatsanddoubles/Double)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+    .property instance float64 D()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance float64 floatsanddoubles/Double::get_D()
+    } 
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@31-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> clo5
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> clo5) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> floatsanddoubles/'main@31-4'::clo5
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.Unit Invoke(float64 arg50) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> floatsanddoubles/'main@31-4'::clo5
+      IL_0006:  ldarg.1
+      IL_0007:  tail.
+      IL_0009:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@31-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> clo4
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> clo4) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> floatsanddoubles/'main@31-3'::clo4
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(float64 arg40) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> floatsanddoubles/'main@31-3'::clo4
+      IL_0006:  ldarg.1
+      IL_0007:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::Invoke(!0)
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  newobj     instance void floatsanddoubles/'main@31-4'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0013:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@31-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> clo3
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> clo3) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> floatsanddoubles/'main@31-2'::clo3
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> Invoke(bool arg30) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> floatsanddoubles/'main@31-2'::clo3
+      IL_0006:  ldarg.1
+      IL_0007:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>::Invoke(!0)
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  newobj     instance void floatsanddoubles/'main@31-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>)
+      IL_0013:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@31-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> clo2
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> clo2) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> floatsanddoubles/'main@31-1'::clo2
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> Invoke(string arg20) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> floatsanddoubles/'main@31-1'::clo2
+      IL_0006:  ldarg.1
+      IL_0007:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>::Invoke(!0)
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  newobj     instance void floatsanddoubles/'main@31-2'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>)
+      IL_0013:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit main@31
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> clo1
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> clo1) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> floatsanddoubles/main@31::clo1
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> Invoke(string arg10) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> floatsanddoubles/main@31::clo1
+      IL_0006:  ldarg.1
+      IL_0007:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>::Invoke(!0)
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  newobj     instance void floatsanddoubles/'main@31-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>)
+      IL_0013:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@36-9'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> clo5
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> clo5) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> floatsanddoubles/'main@36-9'::clo5
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.Unit Invoke(float64 arg50) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> floatsanddoubles/'main@36-9'::clo5
+      IL_0006:  ldarg.1
+      IL_0007:  tail.
+      IL_0009:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@36-8'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> clo4
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> clo4) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> floatsanddoubles/'main@36-8'::clo4
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(float64 arg40) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> floatsanddoubles/'main@36-8'::clo4
+      IL_0006:  ldarg.1
+      IL_0007:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::Invoke(!0)
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  newobj     instance void floatsanddoubles/'main@36-9'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0013:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@36-7'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> clo3
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> clo3) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> floatsanddoubles/'main@36-7'::clo3
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> Invoke(bool arg30) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> floatsanddoubles/'main@36-7'::clo3
+      IL_0006:  ldarg.1
+      IL_0007:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>::Invoke(!0)
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  newobj     instance void floatsanddoubles/'main@36-8'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>)
+      IL_0013:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@36-6'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> clo2
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> clo2) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> floatsanddoubles/'main@36-6'::clo2
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> Invoke(string arg20) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> floatsanddoubles/'main@36-6'::clo2
+      IL_0006:  ldarg.1
+      IL_0007:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>::Invoke(!0)
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  newobj     instance void floatsanddoubles/'main@36-7'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>)
+      IL_0013:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@36-5'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> clo1
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> clo1) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> floatsanddoubles/'main@36-5'::clo1
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> Invoke(string arg10) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> floatsanddoubles/'main@36-5'::clo1
+      IL_0006:  ldarg.1
+      IL_0007:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>::Invoke(!0)
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  newobj     instance void floatsanddoubles/'main@36-6'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>)
+      IL_0013:  ret
+    } 
+
+  } 
+
+  .field static assembly valuetype floatsanddoubles/Float[] floats@22
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly valuetype floatsanddoubles/Double[] doubles@23
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly string[] names@24
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static valuetype floatsanddoubles/Float[] get_floats() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     valuetype floatsanddoubles/Float[] floatsanddoubles::floats@22
+    IL_0005:  ret
+  } 
+
+  .method public specialname static valuetype floatsanddoubles/Double[] get_doubles() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     valuetype floatsanddoubles/Double[] floatsanddoubles::doubles@23
+    IL_0005:  ret
+  } 
+
+  .method public specialname static string[] get_names() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     string[] floatsanddoubles::names@24
+    IL_0005:  ret
+  } 
+
+  .method public static int32  main(string[] argv) cil managed
+  {
+    .entrypoint
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.EntryPointAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  9
+    .locals init (int32 V_0,
+             int32 V_1,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> V_2,
+             int32 V_3,
+             int32 V_4,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> V_5)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$floatsanddoubles::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$floatsanddoubles::init@
+    IL_000b:  pop
+    IL_000c:  ldc.i4.0
+    IL_000d:  stloc.0
+    IL_000e:  br         IL_00b4
+
+    IL_0013:  ldc.i4.0
+    IL_0014:  stloc.1
+    IL_0015:  br.s       IL_0093
+
+    IL_0017:  ldstr      "Doubles:   %-17s = %-17s  is:  %-5b   Values %f = %f"
+    IL_001c:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.Tuple`5<string,string,bool,float64,float64>>::.ctor(string)
+    IL_0021:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0026:  stloc.2
+    IL_0027:  ldloc.2
+    IL_0028:  newobj     instance void floatsanddoubles/main@31::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>)
+    IL_002d:  call       string[] floatsanddoubles::get_names()
+    IL_0032:  ldloc.0
+    IL_0033:  ldelem     [runtime]System.String
+    IL_0038:  call       string[] floatsanddoubles::get_names()
+    IL_003d:  ldloc.1
+    IL_003e:  ldelem     [runtime]System.String
+    IL_0043:  call       valuetype floatsanddoubles/Double[] floatsanddoubles::get_doubles()
+    IL_0048:  ldloc.0
+    IL_0049:  ldelema    floatsanddoubles/Double
+    IL_004e:  call       valuetype floatsanddoubles/Double[] floatsanddoubles::get_doubles()
+    IL_0053:  ldloc.1
+    IL_0054:  ldelem     floatsanddoubles/Double
+    IL_0059:  box        floatsanddoubles/Double
+    IL_005e:  constrained. floatsanddoubles/Double
+    IL_0064:  callvirt   instance bool [runtime]System.Object::Equals(object)
+    IL_0069:  call       valuetype floatsanddoubles/Double[] floatsanddoubles::get_doubles()
+    IL_006e:  ldloc.0
+    IL_006f:  ldelema    floatsanddoubles/Double
+    IL_0074:  ldfld      float64 floatsanddoubles/Double::D@
+    IL_0079:  call       valuetype floatsanddoubles/Double[] floatsanddoubles::get_doubles()
+    IL_007e:  ldloc.1
+    IL_007f:  ldelema    floatsanddoubles/Double
+    IL_0084:  ldfld      float64 floatsanddoubles/Double::D@
+    IL_0089:  call       !!3 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::InvokeFast<bool,float64,float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!1,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!1,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>>>>>,
+                                                                                                                                                                                  !0,
+                                                                                                                                                                                  !1,
+                                                                                                                                                                                  !!0,
+                                                                                                                                                                                  !!1,
+                                                                                                                                                                                  !!2)
+    IL_008e:  pop
+    IL_008f:  ldloc.1
+    IL_0090:  ldc.i4.1
+    IL_0091:  add
+    IL_0092:  stloc.1
+    IL_0093:  ldloc.1
+    IL_0094:  call       valuetype floatsanddoubles/Double[] floatsanddoubles::get_doubles()
+    IL_0099:  ldlen
+    IL_009a:  conv.i4
+    IL_009b:  blt        IL_0017
+
+    IL_00a0:  ldstr      ""
+    IL_00a5:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_00aa:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_00af:  pop
+    IL_00b0:  ldloc.0
+    IL_00b1:  ldc.i4.1
+    IL_00b2:  add
+    IL_00b3:  stloc.0
+    IL_00b4:  ldloc.0
+    IL_00b5:  call       valuetype floatsanddoubles/Double[] floatsanddoubles::get_doubles()
+    IL_00ba:  ldlen
+    IL_00bb:  conv.i4
+    IL_00bc:  blt        IL_0013
+
+    IL_00c1:  ldc.i4.0
+    IL_00c2:  stloc.3
+    IL_00c3:  br         IL_0175
+
+    IL_00c8:  ldc.i4.0
+    IL_00c9:  stloc.s    V_4
+    IL_00cb:  br         IL_0153
+
+    IL_00d0:  ldstr      "Floats:    %-17s = %-17s  is:  %-5b   Values %f = %f"
+    IL_00d5:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.Tuple`5<string,string,bool,float64,float64>>::.ctor(string)
+    IL_00da:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_00df:  stloc.s    V_5
+    IL_00e1:  ldloc.s    V_5
+    IL_00e3:  newobj     instance void floatsanddoubles/'main@36-5'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>)
+    IL_00e8:  call       string[] floatsanddoubles::get_names()
+    IL_00ed:  ldloc.3
+    IL_00ee:  ldelem     [runtime]System.String
+    IL_00f3:  call       string[] floatsanddoubles::get_names()
+    IL_00f8:  ldloc.s    V_4
+    IL_00fa:  ldelem     [runtime]System.String
+    IL_00ff:  call       valuetype floatsanddoubles/Float[] floatsanddoubles::get_floats()
+    IL_0104:  ldloc.3
+    IL_0105:  ldelema    floatsanddoubles/Float
+    IL_010a:  call       valuetype floatsanddoubles/Float[] floatsanddoubles::get_floats()
+    IL_010f:  ldloc.s    V_4
+    IL_0111:  ldelem     floatsanddoubles/Float
+    IL_0116:  box        floatsanddoubles/Float
+    IL_011b:  constrained. floatsanddoubles/Float
+    IL_0121:  callvirt   instance bool [runtime]System.Object::Equals(object)
+    IL_0126:  call       valuetype floatsanddoubles/Float[] floatsanddoubles::get_floats()
+    IL_012b:  ldloc.3
+    IL_012c:  ldelema    floatsanddoubles/Float
+    IL_0131:  ldfld      float64 floatsanddoubles/Float::F@
+    IL_0136:  call       valuetype floatsanddoubles/Float[] floatsanddoubles::get_floats()
+    IL_013b:  ldloc.s    V_4
+    IL_013d:  ldelema    floatsanddoubles/Float
+    IL_0142:  ldfld      float64 floatsanddoubles/Float::F@
+    IL_0147:  call       !!3 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::InvokeFast<bool,float64,float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!1,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!1,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>>>>>,
+                                                                                                                                                                                  !0,
+                                                                                                                                                                                  !1,
+                                                                                                                                                                                  !!0,
+                                                                                                                                                                                  !!1,
+                                                                                                                                                                                  !!2)
+    IL_014c:  pop
+    IL_014d:  ldloc.s    V_4
+    IL_014f:  ldc.i4.1
+    IL_0150:  add
+    IL_0151:  stloc.s    V_4
+    IL_0153:  ldloc.s    V_4
+    IL_0155:  call       valuetype floatsanddoubles/Float[] floatsanddoubles::get_floats()
+    IL_015a:  ldlen
+    IL_015b:  conv.i4
+    IL_015c:  blt        IL_00d0
+
+    IL_0161:  ldstr      ""
+    IL_0166:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_016b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0170:  pop
+    IL_0171:  ldloc.3
+    IL_0172:  ldc.i4.1
+    IL_0173:  add
+    IL_0174:  stloc.3
+    IL_0175:  ldloc.3
+    IL_0176:  call       valuetype floatsanddoubles/Float[] floatsanddoubles::get_floats()
+    IL_017b:  ldlen
+    IL_017c:  conv.i4
+    IL_017d:  blt        IL_00c8
+
+    IL_0182:  ldc.i4.0
+    IL_0183:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$floatsanddoubles::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$floatsanddoubles::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  6
+    IL_0000:  ldc.i4.7
+    IL_0001:  newarr     floatsanddoubles/Float
+    IL_0006:  dup
+    IL_0007:  ldc.i4.0
+    IL_0008:  ldc.r8     4.9406564584124654e-324
+    IL_0011:  newobj     instance void floatsanddoubles/Float::.ctor(float64)
+    IL_0016:  stelem     floatsanddoubles/Float
+    IL_001b:  dup
+    IL_001c:  ldc.i4.1
+    IL_001d:  ldc.r8     -1.7976931348623157e+308
+    IL_0026:  newobj     instance void floatsanddoubles/Float::.ctor(float64)
+    IL_002b:  stelem     floatsanddoubles/Float
+    IL_0030:  dup
+    IL_0031:  ldc.i4.2
+    IL_0032:  ldc.r8     1.7976931348623157e+308
+    IL_003b:  newobj     instance void floatsanddoubles/Float::.ctor(float64)
+    IL_0040:  stelem     floatsanddoubles/Float
+    IL_0045:  dup
+    IL_0046:  ldc.i4.3
+    IL_0047:  ldc.r8     (00 00 00 00 00 00 F0 FF)
+    IL_0050:  newobj     instance void floatsanddoubles/Float::.ctor(float64)
+    IL_0055:  stelem     floatsanddoubles/Float
+    IL_005a:  dup
+    IL_005b:  ldc.i4.4
+    IL_005c:  ldc.r8     (00 00 00 00 00 00 F0 7F)
+    IL_0065:  newobj     instance void floatsanddoubles/Float::.ctor(float64)
+    IL_006a:  stelem     floatsanddoubles/Float
+    IL_006f:  dup
+    IL_0070:  ldc.i4.5
+    IL_0071:  ldc.r8     (00 00 00 00 00 00 F8 FF)
+    IL_007a:  newobj     instance void floatsanddoubles/Float::.ctor(float64)
+    IL_007f:  stelem     floatsanddoubles/Float
+    IL_0084:  dup
+    IL_0085:  ldc.i4.6
+    IL_0086:  ldc.r8     7.0999999999999996
+    IL_008f:  newobj     instance void floatsanddoubles/Float::.ctor(float64)
+    IL_0094:  stelem     floatsanddoubles/Float
+    IL_0099:  stsfld     valuetype floatsanddoubles/Float[] floatsanddoubles::floats@22
+    IL_009e:  ldc.i4.7
+    IL_009f:  newarr     floatsanddoubles/Double
+    IL_00a4:  dup
+    IL_00a5:  ldc.i4.0
+    IL_00a6:  ldc.r8     4.9406564584124654e-324
+    IL_00af:  newobj     instance void floatsanddoubles/Double::.ctor(float64)
+    IL_00b4:  stelem     floatsanddoubles/Double
+    IL_00b9:  dup
+    IL_00ba:  ldc.i4.1
+    IL_00bb:  ldc.r8     -1.7976931348623157e+308
+    IL_00c4:  newobj     instance void floatsanddoubles/Double::.ctor(float64)
+    IL_00c9:  stelem     floatsanddoubles/Double
+    IL_00ce:  dup
+    IL_00cf:  ldc.i4.2
+    IL_00d0:  ldc.r8     1.7976931348623157e+308
+    IL_00d9:  newobj     instance void floatsanddoubles/Double::.ctor(float64)
+    IL_00de:  stelem     floatsanddoubles/Double
+    IL_00e3:  dup
+    IL_00e4:  ldc.i4.3
+    IL_00e5:  ldc.r8     (00 00 00 00 00 00 F0 FF)
+    IL_00ee:  newobj     instance void floatsanddoubles/Double::.ctor(float64)
+    IL_00f3:  stelem     floatsanddoubles/Double
+    IL_00f8:  dup
+    IL_00f9:  ldc.i4.4
+    IL_00fa:  ldc.r8     (00 00 00 00 00 00 F0 7F)
+    IL_0103:  newobj     instance void floatsanddoubles/Double::.ctor(float64)
+    IL_0108:  stelem     floatsanddoubles/Double
+    IL_010d:  dup
+    IL_010e:  ldc.i4.5
+    IL_010f:  ldc.r8     (00 00 00 00 00 00 F8 FF)
+    IL_0118:  newobj     instance void floatsanddoubles/Double::.ctor(float64)
+    IL_011d:  stelem     floatsanddoubles/Double
+    IL_0122:  dup
+    IL_0123:  ldc.i4.6
+    IL_0124:  ldc.r8     8.0999999999999996
+    IL_012d:  newobj     instance void floatsanddoubles/Double::.ctor(float64)
+    IL_0132:  stelem     floatsanddoubles/Double
+    IL_0137:  stsfld     valuetype floatsanddoubles/Double[] floatsanddoubles::doubles@23
+    IL_013c:  ldc.i4.7
+    IL_013d:  newarr     [runtime]System.String
+    IL_0142:  dup
+    IL_0143:  ldc.i4.0
+    IL_0144:  ldstr      "Epsilon"
+    IL_0149:  stelem     [runtime]System.String
+    IL_014e:  dup
+    IL_014f:  ldc.i4.1
+    IL_0150:  ldstr      "MinValue"
+    IL_0155:  stelem     [runtime]System.String
+    IL_015a:  dup
+    IL_015b:  ldc.i4.2
+    IL_015c:  ldstr      "MaxValue"
+    IL_0161:  stelem     [runtime]System.String
+    IL_0166:  dup
+    IL_0167:  ldc.i4.3
+    IL_0168:  ldstr      "NegativeInfinity"
+    IL_016d:  stelem     [runtime]System.String
+    IL_0172:  dup
+    IL_0173:  ldc.i4.4
+    IL_0174:  ldstr      "PositiveInfinity"
+    IL_0179:  stelem     [runtime]System.String
+    IL_017e:  dup
+    IL_017f:  ldc.i4.5
+    IL_0180:  ldstr      "NaN"
+    IL_0185:  stelem     [runtime]System.String
+    IL_018a:  dup
+    IL_018b:  ldc.i4.6
+    IL_018c:  ldstr      "Number"
+    IL_0191:  stelem     [runtime]System.String
+    IL_0196:  stsfld     string[] floatsanddoubles::names@24
+    IL_019b:  ret
+  } 
+
+  .property valuetype floatsanddoubles/Float[]
+          floats()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get valuetype floatsanddoubles/Float[] floatsanddoubles::get_floats()
+  } 
+  .property valuetype floatsanddoubles/Double[]
+          doubles()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get valuetype floatsanddoubles/Double[] floatsanddoubles::get_doubles()
+  } 
+  .property string[] names()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get string[] floatsanddoubles::get_names()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$floatsanddoubles
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void floatsanddoubles::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles_2.fs.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles_2.fs.il.release.bsl
new file mode 100644
index 00000000000..5f275dd75c6
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/FloatsAndDoubles_2.fs.il.release.bsl
@@ -0,0 +1,1383 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed floatsanddoubles
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class sequential ansi serializable sealed nested public Float
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype floatsanddoubles/Float>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype floatsanddoubles/Float>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly float64 F@
+    .method public hidebysig specialname instance float64  get_F() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.IsReadOnlyAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(valuetype floatsanddoubles/Float obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (valuetype floatsanddoubles/Float& V_0,
+               class [runtime]System.Collections.IComparer V_1,
+               float64 V_2,
+               float64 V_3)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0008:  stloc.1
+      IL_0009:  ldarg.0
+      IL_000a:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_000f:  stloc.2
+      IL_0010:  ldloc.0
+      IL_0011:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_0016:  stloc.3
+      IL_0017:  ldloc.2
+      IL_0018:  ldloc.3
+      IL_0019:  clt
+      IL_001b:  brfalse.s  IL_001f
+
+      IL_001d:  ldc.i4.m1
+      IL_001e:  ret
+
+      IL_001f:  ldloc.2
+      IL_0020:  ldloc.3
+      IL_0021:  cgt
+      IL_0023:  brfalse.s  IL_0027
+
+      IL_0025:  ldc.i4.1
+      IL_0026:  ret
+
+      IL_0027:  ldloc.2
+      IL_0028:  ldloc.3
+      IL_0029:  ceq
+      IL_002b:  brfalse.s  IL_002f
+
+      IL_002d:  ldc.i4.0
+      IL_002e:  ret
+
+      IL_002f:  ldloc.1
+      IL_0030:  ldloc.2
+      IL_0031:  ldloc.3
+      IL_0032:  tail.
+      IL_0034:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericComparisonWithComparerIntrinsic<float64>(class [runtime]System.Collections.IComparer,
+                                                                                                                                                    !!0,
+                                                                                                                                                    !!0)
+      IL_0039:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  floatsanddoubles/Float
+      IL_0007:  call       instance int32 floatsanddoubles/Float::CompareTo(valuetype floatsanddoubles/Float)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (valuetype floatsanddoubles/Float V_0,
+               valuetype floatsanddoubles/Float& V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               float64 V_3,
+               float64 V_4)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  floatsanddoubles/Float
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldarg.2
+      IL_000b:  stloc.2
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_0012:  stloc.3
+      IL_0013:  ldloc.1
+      IL_0014:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_0019:  stloc.s    V_4
+      IL_001b:  ldloc.3
+      IL_001c:  ldloc.s    V_4
+      IL_001e:  clt
+      IL_0020:  brfalse.s  IL_0024
+
+      IL_0022:  ldc.i4.m1
+      IL_0023:  ret
+
+      IL_0024:  ldloc.3
+      IL_0025:  ldloc.s    V_4
+      IL_0027:  cgt
+      IL_0029:  brfalse.s  IL_002d
+
+      IL_002b:  ldc.i4.1
+      IL_002c:  ret
+
+      IL_002d:  ldloc.3
+      IL_002e:  ldloc.s    V_4
+      IL_0030:  ceq
+      IL_0032:  brfalse.s  IL_0036
+
+      IL_0034:  ldc.i4.0
+      IL_0035:  ret
+
+      IL_0036:  ldloc.2
+      IL_0037:  ldloc.3
+      IL_0038:  ldloc.s    V_4
+      IL_003a:  tail.
+      IL_003c:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericComparisonWithComparerIntrinsic<float64>(class [runtime]System.Collections.IComparer,
+                                                                                                                                                    !!0,
+                                                                                                                                                    !!0)
+      IL_0041:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldc.i4.0
+      IL_0001:  stloc.0
+      IL_0002:  ldc.i4     0x9e3779b9
+      IL_0007:  ldarg.1
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_000e:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericHashWithComparerIntrinsic<float64>(class [runtime]System.Collections.IEqualityComparer,
+                                                                                                                                              !!0)
+      IL_0013:  ldloc.0
+      IL_0014:  ldc.i4.6
+      IL_0015:  shl
+      IL_0016:  ldloc.0
+      IL_0017:  ldc.i4.2
+      IL_0018:  shr
+      IL_0019:  add
+      IL_001a:  add
+      IL_001b:  add
+      IL_001c:  stloc.0
+      IL_001d:  ldloc.0
+      IL_001e:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 floatsanddoubles/Float::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype floatsanddoubles/Float V_1,
+               valuetype floatsanddoubles/Float& V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     floatsanddoubles/Float
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_0028
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  floatsanddoubles/Float
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldarg.2
+      IL_0018:  stloc.3
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_001f:  ldloc.2
+      IL_0020:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_0025:  ceq
+      IL_0027:  ret
+
+      IL_0028:  ldc.i4.0
+      IL_0029:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor(float64 f) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      float64 floatsanddoubles/Float::F@
+      IL_0007:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(valuetype floatsanddoubles/Float obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype floatsanddoubles/Float& V_0,
+               float64 V_1,
+               float64 V_2)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldarg.0
+      IL_0004:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_0009:  stloc.1
+      IL_000a:  ldloc.0
+      IL_000b:  ldfld      float64 floatsanddoubles/Float::F@
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.1
+      IL_0012:  ldloc.2
+      IL_0013:  ceq
+      IL_0015:  brfalse.s  IL_0019
+
+      IL_0017:  ldc.i4.1
+      IL_0018:  ret
+
+      IL_0019:  ldloc.1
+      IL_001a:  ldloc.1
+      IL_001b:  beq.s      IL_0025
+
+      IL_001d:  ldloc.2
+      IL_001e:  ldloc.2
+      IL_001f:  ceq
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+
+      IL_0025:  ldc.i4.0
+      IL_0026:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype floatsanddoubles/Float V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     floatsanddoubles/Float
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  floatsanddoubles/Float
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool floatsanddoubles/Float::Equals(valuetype floatsanddoubles/Float)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+    .property instance float64 F()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance float64 floatsanddoubles/Float::get_F()
+    } 
+  } 
+
+  .class sequential ansi serializable sealed nested public Double
+         extends [runtime]System.ValueType
+         implements class [runtime]System.IEquatable`1<valuetype floatsanddoubles/Double>,
+                    [runtime]System.Collections.IStructuralEquatable,
+                    class [runtime]System.IComparable`1<valuetype floatsanddoubles/Double>,
+                    [runtime]System.IComparable,
+                    [runtime]System.Collections.IStructuralComparable
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly float64 D@
+    .method public hidebysig specialname instance float64  get_D() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.IsReadOnlyAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(valuetype floatsanddoubles/Double obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (valuetype floatsanddoubles/Double& V_0,
+               class [runtime]System.Collections.IComparer V_1,
+               float64 V_2,
+               float64 V_3)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  call       class [runtime]System.Collections.IComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericComparer()
+      IL_0008:  stloc.1
+      IL_0009:  ldarg.0
+      IL_000a:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_000f:  stloc.2
+      IL_0010:  ldloc.0
+      IL_0011:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_0016:  stloc.3
+      IL_0017:  ldloc.2
+      IL_0018:  ldloc.3
+      IL_0019:  clt
+      IL_001b:  brfalse.s  IL_001f
+
+      IL_001d:  ldc.i4.m1
+      IL_001e:  ret
+
+      IL_001f:  ldloc.2
+      IL_0020:  ldloc.3
+      IL_0021:  cgt
+      IL_0023:  brfalse.s  IL_0027
+
+      IL_0025:  ldc.i4.1
+      IL_0026:  ret
+
+      IL_0027:  ldloc.2
+      IL_0028:  ldloc.3
+      IL_0029:  ceq
+      IL_002b:  brfalse.s  IL_002f
+
+      IL_002d:  ldc.i4.0
+      IL_002e:  ret
+
+      IL_002f:  ldloc.1
+      IL_0030:  ldloc.2
+      IL_0031:  ldloc.3
+      IL_0032:  tail.
+      IL_0034:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericComparisonWithComparerIntrinsic<float64>(class [runtime]System.Collections.IComparer,
+                                                                                                                                                    !!0,
+                                                                                                                                                    !!0)
+      IL_0039:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  CompareTo(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  unbox.any  floatsanddoubles/Double
+      IL_0007:  call       instance int32 floatsanddoubles/Double::CompareTo(valuetype floatsanddoubles/Double)
+      IL_000c:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance int32  CompareTo(object obj,
+                                      class [runtime]System.Collections.IComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (valuetype floatsanddoubles/Double V_0,
+               valuetype floatsanddoubles/Double& V_1,
+               class [runtime]System.Collections.IComparer V_2,
+               float64 V_3,
+               float64 V_4)
+      IL_0000:  ldarg.1
+      IL_0001:  unbox.any  floatsanddoubles/Double
+      IL_0006:  stloc.0
+      IL_0007:  ldloca.s   V_0
+      IL_0009:  stloc.1
+      IL_000a:  ldarg.2
+      IL_000b:  stloc.2
+      IL_000c:  ldarg.0
+      IL_000d:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_0012:  stloc.3
+      IL_0013:  ldloc.1
+      IL_0014:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_0019:  stloc.s    V_4
+      IL_001b:  ldloc.3
+      IL_001c:  ldloc.s    V_4
+      IL_001e:  clt
+      IL_0020:  brfalse.s  IL_0024
+
+      IL_0022:  ldc.i4.m1
+      IL_0023:  ret
+
+      IL_0024:  ldloc.3
+      IL_0025:  ldloc.s    V_4
+      IL_0027:  cgt
+      IL_0029:  brfalse.s  IL_002d
+
+      IL_002b:  ldc.i4.1
+      IL_002c:  ret
+
+      IL_002d:  ldloc.3
+      IL_002e:  ldloc.s    V_4
+      IL_0030:  ceq
+      IL_0032:  brfalse.s  IL_0036
+
+      IL_0034:  ldc.i4.0
+      IL_0035:  ret
+
+      IL_0036:  ldloc.2
+      IL_0037:  ldloc.3
+      IL_0038:  ldloc.s    V_4
+      IL_003a:  tail.
+      IL_003c:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericComparisonWithComparerIntrinsic<float64>(class [runtime]System.Collections.IComparer,
+                                                                                                                                                    !!0,
+                                                                                                                                                    !!0)
+      IL_0041:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode(class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  7
+      .locals init (int32 V_0)
+      IL_0000:  ldc.i4.0
+      IL_0001:  stloc.0
+      IL_0002:  ldc.i4     0x9e3779b9
+      IL_0007:  ldarg.1
+      IL_0008:  ldarg.0
+      IL_0009:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_000e:  call       int32 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/HashCompare::GenericHashWithComparerIntrinsic<float64>(class [runtime]System.Collections.IEqualityComparer,
+                                                                                                                                              !!0)
+      IL_0013:  ldloc.0
+      IL_0014:  ldc.i4.6
+      IL_0015:  shl
+      IL_0016:  ldloc.0
+      IL_0017:  ldc.i4.2
+      IL_0018:  shr
+      IL_0019:  add
+      IL_001a:  add
+      IL_001b:  add
+      IL_001c:  stloc.0
+      IL_001d:  ldloc.0
+      IL_001e:  ret
+    } 
+
+    .method public hidebysig virtual final instance int32  GetHashCode() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       class [runtime]System.Collections.IEqualityComparer [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives::get_GenericEqualityComparer()
+      IL_0006:  call       instance int32 floatsanddoubles/Double::GetHashCode(class [runtime]System.Collections.IEqualityComparer)
+      IL_000b:  ret
+    } 
+
+    .method public hidebysig virtual final 
+            instance bool  Equals(object obj,
+                                  class [runtime]System.Collections.IEqualityComparer comp) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype floatsanddoubles/Double V_1,
+               valuetype floatsanddoubles/Double& V_2,
+               class [runtime]System.Collections.IEqualityComparer V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     floatsanddoubles/Double
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_0028
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  floatsanddoubles/Double
+      IL_0013:  stloc.1
+      IL_0014:  ldloca.s   V_1
+      IL_0016:  stloc.2
+      IL_0017:  ldarg.2
+      IL_0018:  stloc.3
+      IL_0019:  ldarg.0
+      IL_001a:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_001f:  ldloc.2
+      IL_0020:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_0025:  ceq
+      IL_0027:  ret
+
+      IL_0028:  ldc.i4.0
+      IL_0029:  ret
+    } 
+
+    .method public specialname rtspecialname instance void  .ctor(float64 d) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      float64 floatsanddoubles/Double::D@
+      IL_0007:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(valuetype floatsanddoubles/Double obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (valuetype floatsanddoubles/Double& V_0,
+               float64 V_1,
+               float64 V_2)
+      IL_0000:  ldarga.s   obj
+      IL_0002:  stloc.0
+      IL_0003:  ldarg.0
+      IL_0004:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_0009:  stloc.1
+      IL_000a:  ldloc.0
+      IL_000b:  ldfld      float64 floatsanddoubles/Double::D@
+      IL_0010:  stloc.2
+      IL_0011:  ldloc.1
+      IL_0012:  ldloc.2
+      IL_0013:  ceq
+      IL_0015:  brfalse.s  IL_0019
+
+      IL_0017:  ldc.i4.1
+      IL_0018:  ret
+
+      IL_0019:  ldloc.1
+      IL_001a:  ldloc.1
+      IL_001b:  beq.s      IL_0025
+
+      IL_001d:  ldloc.2
+      IL_001e:  ldloc.2
+      IL_001f:  ceq
+      IL_0021:  ldc.i4.0
+      IL_0022:  ceq
+      IL_0024:  ret
+
+      IL_0025:  ldc.i4.0
+      IL_0026:  ret
+    } 
+
+    .method public hidebysig virtual final instance bool  Equals(object obj) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  4
+      .locals init (object V_0,
+               valuetype floatsanddoubles/Double V_1)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  isinst     floatsanddoubles/Double
+      IL_0008:  ldnull
+      IL_0009:  cgt.un
+      IL_000b:  brfalse.s  IL_001c
+
+      IL_000d:  ldarg.1
+      IL_000e:  unbox.any  floatsanddoubles/Double
+      IL_0013:  stloc.1
+      IL_0014:  ldarg.0
+      IL_0015:  ldloc.1
+      IL_0016:  call       instance bool floatsanddoubles/Double::Equals(valuetype floatsanddoubles/Double)
+      IL_001b:  ret
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  ret
+    } 
+
+    .property instance float64 D()
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags,
+                                                                                                  int32) = ( 01 00 04 00 00 00 00 00 00 00 00 00 ) 
+      .get instance float64 floatsanddoubles/Double::get_D()
+    } 
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@31-4'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> clo5
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> clo5) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> floatsanddoubles/'main@31-4'::clo5
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.Unit Invoke(float64 arg50) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> floatsanddoubles/'main@31-4'::clo5
+      IL_0006:  ldarg.1
+      IL_0007:  tail.
+      IL_0009:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@31-3'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> clo4
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> clo4) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> floatsanddoubles/'main@31-3'::clo4
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(float64 arg40) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> floatsanddoubles/'main@31-3'::clo4
+      IL_0006:  ldarg.1
+      IL_0007:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::Invoke(!0)
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  newobj     instance void floatsanddoubles/'main@31-4'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0013:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@31-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> clo3
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> clo3) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> floatsanddoubles/'main@31-2'::clo3
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> Invoke(bool arg30) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> floatsanddoubles/'main@31-2'::clo3
+      IL_0006:  ldarg.1
+      IL_0007:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>::Invoke(!0)
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  newobj     instance void floatsanddoubles/'main@31-3'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>)
+      IL_0013:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@31-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> clo2
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> clo2) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> floatsanddoubles/'main@31-1'::clo2
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> Invoke(string arg20) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> floatsanddoubles/'main@31-1'::clo2
+      IL_0006:  ldarg.1
+      IL_0007:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>::Invoke(!0)
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  newobj     instance void floatsanddoubles/'main@31-2'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>)
+      IL_0013:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit main@31
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> clo1
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> clo1) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> floatsanddoubles/main@31::clo1
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> Invoke(string arg10) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> floatsanddoubles/main@31::clo1
+      IL_0006:  ldarg.1
+      IL_0007:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>::Invoke(!0)
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  newobj     instance void floatsanddoubles/'main@31-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>)
+      IL_0013:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@36-9'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> clo5
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> clo5) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> floatsanddoubles/'main@36-9'::clo5
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.Unit Invoke(float64 arg50) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> floatsanddoubles/'main@36-9'::clo5
+      IL_0006:  ldarg.1
+      IL_0007:  tail.
+      IL_0009:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@36-8'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> clo4
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> clo4) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> floatsanddoubles/'main@36-8'::clo4
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> Invoke(float64 arg40) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> floatsanddoubles/'main@36-8'::clo4
+      IL_0006:  ldarg.1
+      IL_0007:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>::Invoke(!0)
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  newobj     instance void floatsanddoubles/'main@36-9'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+      IL_0013:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@36-7'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> clo3
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> clo3) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> floatsanddoubles/'main@36-7'::clo3
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> Invoke(bool arg30) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> floatsanddoubles/'main@36-7'::clo3
+      IL_0006:  ldarg.1
+      IL_0007:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>::Invoke(!0)
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  newobj     instance void floatsanddoubles/'main@36-8'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>)
+      IL_0013:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@36-6'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> clo2
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> clo2) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> floatsanddoubles/'main@36-6'::clo2
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> Invoke(string arg20) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> floatsanddoubles/'main@36-6'::clo2
+      IL_0006:  ldarg.1
+      IL_0007:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>::Invoke(!0)
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  newobj     instance void floatsanddoubles/'main@36-7'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>)
+      IL_0013:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'main@36-5'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> clo1
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> clo1) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> floatsanddoubles/'main@36-5'::clo1
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> Invoke(string arg10) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>> V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> floatsanddoubles/'main@36-5'::clo1
+      IL_0006:  ldarg.1
+      IL_0007:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>::Invoke(!0)
+      IL_000c:  stloc.0
+      IL_000d:  ldloc.0
+      IL_000e:  newobj     instance void floatsanddoubles/'main@36-6'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>)
+      IL_0013:  ret
+    } 
+
+  } 
+
+  .field static assembly valuetype floatsanddoubles/Float[] floats@22
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly valuetype floatsanddoubles/Double[] doubles@23
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly string[] names@24
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static valuetype floatsanddoubles/Float[] get_floats() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     valuetype floatsanddoubles/Float[] floatsanddoubles::floats@22
+    IL_0005:  ret
+  } 
+
+  .method public specialname static valuetype floatsanddoubles/Double[] get_doubles() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     valuetype floatsanddoubles/Double[] floatsanddoubles::doubles@23
+    IL_0005:  ret
+  } 
+
+  .method public specialname static string[] get_names() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     string[] floatsanddoubles::names@24
+    IL_0005:  ret
+  } 
+
+  .method public static int32  main(string[] argv) cil managed
+  {
+    .entrypoint
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.EntryPointAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  9
+    .locals init (int32 V_0,
+             int32 V_1,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> V_2,
+             int32 V_3,
+             int32 V_4,
+             class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>> V_5)
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$floatsanddoubles::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$floatsanddoubles::init@
+    IL_000b:  pop
+    IL_000c:  ldc.i4.0
+    IL_000d:  stloc.0
+    IL_000e:  br         IL_00b4
+
+    IL_0013:  ldc.i4.0
+    IL_0014:  stloc.1
+    IL_0015:  br.s       IL_0093
+
+    IL_0017:  ldstr      "Doubles:   %-17s = %-17s  is:  %-5b   Values %f = %f"
+    IL_001c:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.Tuple`5<string,string,bool,float64,float64>>::.ctor(string)
+    IL_0021:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0026:  stloc.2
+    IL_0027:  ldloc.2
+    IL_0028:  newobj     instance void floatsanddoubles/main@31::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>)
+    IL_002d:  call       string[] floatsanddoubles::get_names()
+    IL_0032:  ldloc.0
+    IL_0033:  ldelem     [runtime]System.String
+    IL_0038:  call       string[] floatsanddoubles::get_names()
+    IL_003d:  ldloc.1
+    IL_003e:  ldelem     [runtime]System.String
+    IL_0043:  call       valuetype floatsanddoubles/Double[] floatsanddoubles::get_doubles()
+    IL_0048:  ldloc.0
+    IL_0049:  ldelema    floatsanddoubles/Double
+    IL_004e:  call       valuetype floatsanddoubles/Double[] floatsanddoubles::get_doubles()
+    IL_0053:  ldloc.1
+    IL_0054:  ldelem     floatsanddoubles/Double
+    IL_0059:  box        floatsanddoubles/Double
+    IL_005e:  constrained. floatsanddoubles/Double
+    IL_0064:  callvirt   instance bool [runtime]System.Object::Equals(object)
+    IL_0069:  call       valuetype floatsanddoubles/Double[] floatsanddoubles::get_doubles()
+    IL_006e:  ldloc.0
+    IL_006f:  ldelema    floatsanddoubles/Double
+    IL_0074:  ldfld      float64 floatsanddoubles/Double::D@
+    IL_0079:  call       valuetype floatsanddoubles/Double[] floatsanddoubles::get_doubles()
+    IL_007e:  ldloc.1
+    IL_007f:  ldelema    floatsanddoubles/Double
+    IL_0084:  ldfld      float64 floatsanddoubles/Double::D@
+    IL_0089:  call       !!3 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::InvokeFast<bool,float64,float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!1,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!1,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>>>>>,
+                                                                                                                                                                                  !0,
+                                                                                                                                                                                  !1,
+                                                                                                                                                                                  !!0,
+                                                                                                                                                                                  !!1,
+                                                                                                                                                                                  !!2)
+    IL_008e:  pop
+    IL_008f:  ldloc.1
+    IL_0090:  ldc.i4.1
+    IL_0091:  add
+    IL_0092:  stloc.1
+    IL_0093:  ldloc.1
+    IL_0094:  call       valuetype floatsanddoubles/Double[] floatsanddoubles::get_doubles()
+    IL_0099:  ldlen
+    IL_009a:  conv.i4
+    IL_009b:  blt        IL_0017
+
+    IL_00a0:  ldstr      ""
+    IL_00a5:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_00aa:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_00af:  pop
+    IL_00b0:  ldloc.0
+    IL_00b1:  ldc.i4.1
+    IL_00b2:  add
+    IL_00b3:  stloc.0
+    IL_00b4:  ldloc.0
+    IL_00b5:  call       valuetype floatsanddoubles/Double[] floatsanddoubles::get_doubles()
+    IL_00ba:  ldlen
+    IL_00bb:  conv.i4
+    IL_00bc:  blt        IL_0013
+
+    IL_00c1:  ldc.i4.0
+    IL_00c2:  stloc.3
+    IL_00c3:  br         IL_0175
+
+    IL_00c8:  ldc.i4.0
+    IL_00c9:  stloc.s    V_4
+    IL_00cb:  br         IL_0153
+
+    IL_00d0:  ldstr      "Floats:    %-17s = %-17s  is:  %-5b   Values %f = %f"
+    IL_00d5:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.Tuple`5<string,string,bool,float64,float64>>::.ctor(string)
+    IL_00da:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_00df:  stloc.s    V_5
+    IL_00e1:  ldloc.s    V_5
+    IL_00e3:  newobj     instance void floatsanddoubles/'main@36-5'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<bool,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>>>>)
+    IL_00e8:  call       string[] floatsanddoubles::get_names()
+    IL_00ed:  ldloc.3
+    IL_00ee:  ldelem     [runtime]System.String
+    IL_00f3:  call       string[] floatsanddoubles::get_names()
+    IL_00f8:  ldloc.s    V_4
+    IL_00fa:  ldelem     [runtime]System.String
+    IL_00ff:  call       valuetype floatsanddoubles/Float[] floatsanddoubles::get_floats()
+    IL_0104:  ldloc.3
+    IL_0105:  ldelema    floatsanddoubles/Float
+    IL_010a:  call       valuetype floatsanddoubles/Float[] floatsanddoubles::get_floats()
+    IL_010f:  ldloc.s    V_4
+    IL_0111:  ldelem     floatsanddoubles/Float
+    IL_0116:  box        floatsanddoubles/Float
+    IL_011b:  constrained. floatsanddoubles/Float
+    IL_0121:  callvirt   instance bool [runtime]System.Object::Equals(object)
+    IL_0126:  call       valuetype floatsanddoubles/Float[] floatsanddoubles::get_floats()
+    IL_012b:  ldloc.3
+    IL_012c:  ldelema    floatsanddoubles/Float
+    IL_0131:  ldfld      float64 floatsanddoubles/Float::F@
+    IL_0136:  call       valuetype floatsanddoubles/Float[] floatsanddoubles::get_floats()
+    IL_013b:  ldloc.s    V_4
+    IL_013d:  ldelema    floatsanddoubles/Float
+    IL_0142:  ldfld      float64 floatsanddoubles/Float::F@
+    IL_0147:  call       !!3 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<string,string>::InvokeFast<bool,float64,float64,class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!1,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!0,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!1,class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<!!2,!!3>>>>>,
+                                                                                                                                                                                  !0,
+                                                                                                                                                                                  !1,
+                                                                                                                                                                                  !!0,
+                                                                                                                                                                                  !!1,
+                                                                                                                                                                                  !!2)
+    IL_014c:  pop
+    IL_014d:  ldloc.s    V_4
+    IL_014f:  ldc.i4.1
+    IL_0150:  add
+    IL_0151:  stloc.s    V_4
+    IL_0153:  ldloc.s    V_4
+    IL_0155:  call       valuetype floatsanddoubles/Float[] floatsanddoubles::get_floats()
+    IL_015a:  ldlen
+    IL_015b:  conv.i4
+    IL_015c:  blt        IL_00d0
+
+    IL_0161:  ldstr      ""
+    IL_0166:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_016b:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_0170:  pop
+    IL_0171:  ldloc.3
+    IL_0172:  ldc.i4.1
+    IL_0173:  add
+    IL_0174:  stloc.3
+    IL_0175:  ldloc.3
+    IL_0176:  call       valuetype floatsanddoubles/Float[] floatsanddoubles::get_floats()
+    IL_017b:  ldlen
+    IL_017c:  conv.i4
+    IL_017d:  blt        IL_00c8
+
+    IL_0182:  ldc.i4.0
+    IL_0183:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$floatsanddoubles::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$floatsanddoubles::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  6
+    IL_0000:  ldc.i4.7
+    IL_0001:  newarr     floatsanddoubles/Float
+    IL_0006:  dup
+    IL_0007:  ldc.i4.0
+    IL_0008:  ldc.r8     4.9406564584124654e-324
+    IL_0011:  newobj     instance void floatsanddoubles/Float::.ctor(float64)
+    IL_0016:  stelem     floatsanddoubles/Float
+    IL_001b:  dup
+    IL_001c:  ldc.i4.1
+    IL_001d:  ldc.r8     -1.7976931348623157e+308
+    IL_0026:  newobj     instance void floatsanddoubles/Float::.ctor(float64)
+    IL_002b:  stelem     floatsanddoubles/Float
+    IL_0030:  dup
+    IL_0031:  ldc.i4.2
+    IL_0032:  ldc.r8     1.7976931348623157e+308
+    IL_003b:  newobj     instance void floatsanddoubles/Float::.ctor(float64)
+    IL_0040:  stelem     floatsanddoubles/Float
+    IL_0045:  dup
+    IL_0046:  ldc.i4.3
+    IL_0047:  ldc.r8     (00 00 00 00 00 00 F0 FF)
+    IL_0050:  newobj     instance void floatsanddoubles/Float::.ctor(float64)
+    IL_0055:  stelem     floatsanddoubles/Float
+    IL_005a:  dup
+    IL_005b:  ldc.i4.4
+    IL_005c:  ldc.r8     (00 00 00 00 00 00 F0 7F)
+    IL_0065:  newobj     instance void floatsanddoubles/Float::.ctor(float64)
+    IL_006a:  stelem     floatsanddoubles/Float
+    IL_006f:  dup
+    IL_0070:  ldc.i4.5
+    IL_0071:  ldc.r8     (00 00 00 00 00 00 F8 FF)
+    IL_007a:  newobj     instance void floatsanddoubles/Float::.ctor(float64)
+    IL_007f:  stelem     floatsanddoubles/Float
+    IL_0084:  dup
+    IL_0085:  ldc.i4.6
+    IL_0086:  ldc.r8     7.0999999999999996
+    IL_008f:  newobj     instance void floatsanddoubles/Float::.ctor(float64)
+    IL_0094:  stelem     floatsanddoubles/Float
+    IL_0099:  stsfld     valuetype floatsanddoubles/Float[] floatsanddoubles::floats@22
+    IL_009e:  ldc.i4.7
+    IL_009f:  newarr     floatsanddoubles/Double
+    IL_00a4:  dup
+    IL_00a5:  ldc.i4.0
+    IL_00a6:  ldc.r8     4.9406564584124654e-324
+    IL_00af:  newobj     instance void floatsanddoubles/Double::.ctor(float64)
+    IL_00b4:  stelem     floatsanddoubles/Double
+    IL_00b9:  dup
+    IL_00ba:  ldc.i4.1
+    IL_00bb:  ldc.r8     -1.7976931348623157e+308
+    IL_00c4:  newobj     instance void floatsanddoubles/Double::.ctor(float64)
+    IL_00c9:  stelem     floatsanddoubles/Double
+    IL_00ce:  dup
+    IL_00cf:  ldc.i4.2
+    IL_00d0:  ldc.r8     1.7976931348623157e+308
+    IL_00d9:  newobj     instance void floatsanddoubles/Double::.ctor(float64)
+    IL_00de:  stelem     floatsanddoubles/Double
+    IL_00e3:  dup
+    IL_00e4:  ldc.i4.3
+    IL_00e5:  ldc.r8     (00 00 00 00 00 00 F0 FF)
+    IL_00ee:  newobj     instance void floatsanddoubles/Double::.ctor(float64)
+    IL_00f3:  stelem     floatsanddoubles/Double
+    IL_00f8:  dup
+    IL_00f9:  ldc.i4.4
+    IL_00fa:  ldc.r8     (00 00 00 00 00 00 F0 7F)
+    IL_0103:  newobj     instance void floatsanddoubles/Double::.ctor(float64)
+    IL_0108:  stelem     floatsanddoubles/Double
+    IL_010d:  dup
+    IL_010e:  ldc.i4.5
+    IL_010f:  ldc.r8     (00 00 00 00 00 00 F8 FF)
+    IL_0118:  newobj     instance void floatsanddoubles/Double::.ctor(float64)
+    IL_011d:  stelem     floatsanddoubles/Double
+    IL_0122:  dup
+    IL_0123:  ldc.i4.6
+    IL_0124:  ldc.r8     8.0999999999999996
+    IL_012d:  newobj     instance void floatsanddoubles/Double::.ctor(float64)
+    IL_0132:  stelem     floatsanddoubles/Double
+    IL_0137:  stsfld     valuetype floatsanddoubles/Double[] floatsanddoubles::doubles@23
+    IL_013c:  ldc.i4.7
+    IL_013d:  newarr     [runtime]System.String
+    IL_0142:  dup
+    IL_0143:  ldc.i4.0
+    IL_0144:  ldstr      "Epsilon"
+    IL_0149:  stelem     [runtime]System.String
+    IL_014e:  dup
+    IL_014f:  ldc.i4.1
+    IL_0150:  ldstr      "MinValue"
+    IL_0155:  stelem     [runtime]System.String
+    IL_015a:  dup
+    IL_015b:  ldc.i4.2
+    IL_015c:  ldstr      "MaxValue"
+    IL_0161:  stelem     [runtime]System.String
+    IL_0166:  dup
+    IL_0167:  ldc.i4.3
+    IL_0168:  ldstr      "NegativeInfinity"
+    IL_016d:  stelem     [runtime]System.String
+    IL_0172:  dup
+    IL_0173:  ldc.i4.4
+    IL_0174:  ldstr      "PositiveInfinity"
+    IL_0179:  stelem     [runtime]System.String
+    IL_017e:  dup
+    IL_017f:  ldc.i4.5
+    IL_0180:  ldstr      "NaN"
+    IL_0185:  stelem     [runtime]System.String
+    IL_018a:  dup
+    IL_018b:  ldc.i4.6
+    IL_018c:  ldstr      "Number"
+    IL_0191:  stelem     [runtime]System.String
+    IL_0196:  stsfld     string[] floatsanddoubles::names@24
+    IL_019b:  ret
+  } 
+
+  .property valuetype floatsanddoubles/Float[]
+          floats()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get valuetype floatsanddoubles/Float[] floatsanddoubles::get_floats()
+  } 
+  .property valuetype floatsanddoubles/Double[]
+          doubles()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get valuetype floatsanddoubles/Double[] floatsanddoubles::get_doubles()
+  } 
+  .property string[] names()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get string[] floatsanddoubles::get_names()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$floatsanddoubles
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void floatsanddoubles::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/Structure.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/Structure.fs
index ee656354ef8..2d542bddee5 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/Structure.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Structure/Structure.fs
@@ -137,10 +137,18 @@ module Structure =
         compilation
         |> verifyCompilation
 
-    // SOURCE=FloatsAndDoubles.fs  SCFLAGS="-g --out:FloatsAndDoubles.exe" COMPILE_ONLY=1 POSTCMD="comparebsl.cmd  FloatsAndDoubles.exe" # FloatsAndDoubles.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"FloatsAndDoubles.fs"|])>]
-    let ``FloatsAndDoubles_fs`` compilation =
+    // SOURCE=FloatsAndDoubles_1.fs  SCFLAGS="-g --out:FloatsAndDoubles.exe" COMPILE_ONLY=1 POSTCMD="comparebsl.cmd  FloatsAndDoubles.exe" # FloatsAndDoubles.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"FloatsAndDoubles_1.fs"|])>]
+    let ``FloatsAndDoubles_1_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
+        |> verifyIl
+
+    // SOURCE=FloatsAndDoubles_2.fs  SCFLAGS="-g --out:FloatsAndDoubles.exe" COMPILE_ONLY=1 POSTCMD="comparebsl.cmd  FloatsAndDoubles.exe" # FloatsAndDoubles.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"FloatsAndDoubles_2.fs"|])>]
+    let ``FloatsAndDoubles_2_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
         |> verifyIl
 
     // SOURCE=FunctionArity01.fs     SCFLAGS="-r:CodeGenHelper.dll" # FunctionArity01.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction09b4.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction09b4_RealInternalSignatureOff.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction09b4.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction09b4_RealInternalSignatureOff.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction09b4.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction09b4_RealInternalSignatureOff.fs.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction09b4.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction09b4_RealInternalSignatureOff.fs.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction09b4_RealInternalSignatureOn.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction09b4_RealInternalSignatureOn.fs
new file mode 100644
index 00000000000..e2cd598647c
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction09b4_RealInternalSignatureOn.fs
@@ -0,0 +1,14 @@
+// #Regression #NoMono #NoMT #CodeGen #EmittedIL 
+// Regression test for FSHARP1.0:2484
+// Note: we might see changes related to another bug
+// related to spans
+#light
+
+[<Literal>]
+let Null = null
+
+let x = 5
+
+match box x with                    // bp here
+  | Null -> printfn "Is null"       // bp here
+  | _ -> ()
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction09b4_RealInternalSignatureOn.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction09b4_RealInternalSignatureOn.fs.il.bsl
new file mode 100644
index 00000000000..c7cc5bdf8c7
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction09b4_RealInternalSignatureOn.fs.il.bsl
@@ -0,0 +1,129 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static !!a  Null<class a>() cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.LiteralAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  3
+    .locals init (!!a V_0)
+    IL_0000:  ldloc.0
+    IL_0001:  ret
+  } 
+
+  .method public specialname static int32 get_x() cil managed
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.5
+    IL_0001:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  nop
+    IL_0002:  call       int32 assembly::get_x()
+    IL_0007:  box        [runtime]System.Int32
+    IL_000c:  brfalse.s  IL_0010
+
+    IL_000e:  br.s       IL_0023
+
+    IL_0010:  ldstr      "Is null"
+    IL_0015:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::.ctor(string)
+    IL_001a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.Unit>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_001f:  pop
+    IL_0020:  nop
+    IL_0021:  br.s       IL_0025
+
+    IL_0023:  nop
+    IL_0024:  nop
+    IL_0025:  ret
+  } 
+
+  .property int32 x()
+  {
+    .get int32 assembly::get_x()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22_RealInternalSignatureOff.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22_RealInternalSignatureOff.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22_RealInternalSignatureOff.fs.il.net472.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22.fs.il.net472.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22_RealInternalSignatureOff.fs.il.net472.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22_RealInternalSignatureOff.fs.il.netcore.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22.fs.il.netcore.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22_RealInternalSignatureOff.fs.il.netcore.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22_RealInternalSignatureOn.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22_RealInternalSignatureOn.fs
new file mode 100644
index 00000000000..0a15c1e7f3e
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22_RealInternalSignatureOn.fs
@@ -0,0 +1,3 @@
+// #NoMono #NoMT #CodeGen #EmittedIL 
+#light
+System.Console.WriteLine()
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22_RealInternalSignatureOn.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22_RealInternalSignatureOn.fs.il.net472.bsl
new file mode 100644
index 00000000000..c6a7bd32400
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22_RealInternalSignatureOn.fs.il.net472.bsl
@@ -0,0 +1,89 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void [runtime]System.Console::WriteLine()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22_RealInternalSignatureOn.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22_RealInternalSignatureOn.fs.il.netcore.bsl
new file mode 100644
index 00000000000..cda3dec5378
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22_RealInternalSignatureOn.fs.il.netcore.bsl
@@ -0,0 +1,90 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern runtime { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void [runtime]System.Console::WriteLine()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b_RealInternalSignatureOff.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b_RealInternalSignatureOff.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b_RealInternalSignatureOff.fs.il.net472.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b.fs.il.net472.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b_RealInternalSignatureOff.fs.il.net472.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b_RealInternalSignatureOff.fs.il.netcore.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b.fs.il.netcore.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b_RealInternalSignatureOff.fs.il.netcore.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b_RealInternalSignatureOn.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b_RealInternalSignatureOn.fs
new file mode 100644
index 00000000000..b0bb870e52c
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b_RealInternalSignatureOn.fs
@@ -0,0 +1,3 @@
+// #NoMono #NoMT #CodeGen #EmittedIL 
+#light
+let _ = System.Console.WriteLine()
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b_RealInternalSignatureOn.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b_RealInternalSignatureOn.fs.il.net472.bsl
new file mode 100644
index 00000000000..c6a7bd32400
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b_RealInternalSignatureOn.fs.il.net472.bsl
@@ -0,0 +1,89 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void [runtime]System.Console::WriteLine()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b_RealInternalSignatureOn.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b_RealInternalSignatureOn.fs.il.netcore.bsl
new file mode 100644
index 00000000000..cda3dec5378
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22b_RealInternalSignatureOn.fs.il.netcore.bsl
@@ -0,0 +1,90 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern runtime { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void [runtime]System.Console::WriteLine()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c_RealInternalSignatureOff.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c_RealInternalSignatureOff.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c_RealInternalSignatureOff.fs.il.net472.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c.fs.il.net472.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c_RealInternalSignatureOff.fs.il.net472.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c_RealInternalSignatureOff.fs.il.netcore.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c.fs.il.netcore.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c_RealInternalSignatureOff.fs.il.netcore.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c_RealInternalSignatureOn.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c_RealInternalSignatureOn.fs
new file mode 100644
index 00000000000..107a0547a4c
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c_RealInternalSignatureOn.fs
@@ -0,0 +1,3 @@
+// #NoMono #NoMT #CodeGen #EmittedIL 
+#light
+let () = System.Console.WriteLine()
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c_RealInternalSignatureOn.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c_RealInternalSignatureOn.fs.il.net472.bsl
new file mode 100644
index 00000000000..c6a7bd32400
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c_RealInternalSignatureOn.fs.il.net472.bsl
@@ -0,0 +1,89 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void [runtime]System.Console::WriteLine()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c_RealInternalSignatureOn.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c_RealInternalSignatureOn.fs.il.netcore.bsl
new file mode 100644
index 00000000000..cda3dec5378
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22c_RealInternalSignatureOn.fs.il.netcore.bsl
@@ -0,0 +1,90 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern runtime { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void [runtime]System.Console::WriteLine()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d_RealInternalSignatureOff.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d_RealInternalSignatureOff.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d_RealInternalSignatureOff.fs.il.net472.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d.fs.il.net472.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d_RealInternalSignatureOff.fs.il.net472.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d_RealInternalSignatureOff.fs.il.netcore.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d.fs.il.netcore.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d_RealInternalSignatureOff.fs.il.netcore.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d_RealInternalSignatureOn.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d_RealInternalSignatureOn.fs
new file mode 100644
index 00000000000..9e9cf22b6dd
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d_RealInternalSignatureOn.fs
@@ -0,0 +1,3 @@
+// #NoMono #NoMT #CodeGen #EmittedIL 
+#light
+do System.Console.WriteLine()
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d_RealInternalSignatureOn.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d_RealInternalSignatureOn.fs.il.net472.bsl
new file mode 100644
index 00000000000..c6a7bd32400
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d_RealInternalSignatureOn.fs.il.net472.bsl
@@ -0,0 +1,89 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void [runtime]System.Console::WriteLine()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d_RealInternalSignatureOn.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d_RealInternalSignatureOn.fs.il.netcore.bsl
new file mode 100644
index 00000000000..cda3dec5378
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22d_RealInternalSignatureOn.fs.il.netcore.bsl
@@ -0,0 +1,90 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern runtime { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void [runtime]System.Console::WriteLine()
+    IL_0005:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e_RealInternalSignatureOff.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e_RealInternalSignatureOff.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e_RealInternalSignatureOff.fs.il.net472.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e.fs.il.net472.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e_RealInternalSignatureOff.fs.il.net472.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e_RealInternalSignatureOff.fs.il.netcore.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e.fs.il.netcore.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e_RealInternalSignatureOff.fs.il.netcore.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e_RealInternalSignatureOn.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e_RealInternalSignatureOn.fs
new file mode 100644
index 00000000000..ef4a3242125
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e_RealInternalSignatureOn.fs
@@ -0,0 +1,4 @@
+// #NoMono #NoMT #CodeGen #EmittedIL 
+#light
+while true do
+   System.Console.WriteLine()
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e_RealInternalSignatureOn.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e_RealInternalSignatureOn.fs.il.net472.bsl
new file mode 100644
index 00000000000..8570fbc7b34
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e_RealInternalSignatureOn.fs.il.net472.bsl
@@ -0,0 +1,94 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  br.s       IL_0007
+
+    IL_0002:  call       void [runtime]System.Console::WriteLine()
+    IL_0007:  ldc.i4.1
+    IL_0008:  brtrue.s   IL_0002
+
+    IL_000a:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e_RealInternalSignatureOn.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e_RealInternalSignatureOn.fs.il.netcore.bsl
new file mode 100644
index 00000000000..f9537f15400
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22e_RealInternalSignatureOn.fs.il.netcore.bsl
@@ -0,0 +1,95 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern runtime { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  br.s       IL_0007
+
+    IL_0002:  call       void [runtime]System.Console::WriteLine()
+    IL_0007:  ldc.i4.1
+    IL_0008:  brtrue.s   IL_0002
+
+    IL_000a:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOff.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOff.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOff.fs.il.net472.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f.fs.il.net472.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOff.fs.il.net472.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOff.fs.il.netcore.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f.fs.il.netcore.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOff.fs.il.netcore.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOn.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOn.fs
new file mode 100644
index 00000000000..6fd7e43ade2
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOn.fs
@@ -0,0 +1,5 @@
+// #NoMono #NoMT #CodeGen #EmittedIL 
+#light
+match "A" with
+  | "A" -> System.Console.WriteLine()
+  | _ -> System.Console.WriteLine()
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOn.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOn.fs.il.bsl
new file mode 100644
index 00000000000..f12cd199eda
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOn.fs.il.bsl
@@ -0,0 +1,109 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly extern runtime { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (string V_0)
+    IL_0000:  ldstr      "A"
+    IL_0005:  stloc.0
+    IL_0006:  ldloc.0
+    IL_0007:  ldstr      "A"
+    IL_000c:  call       bool [netstandard]System.String::Equals(string,
+                                                                 string)
+    IL_0011:  brfalse.s  IL_001b
+
+    IL_0013:  call       void [runtime]System.Console::WriteLine()
+    IL_0018:  nop
+    IL_0019:  br.s       IL_0021
+
+    IL_001b:  call       void [runtime]System.Console::WriteLine()
+    IL_0020:  nop
+    IL_0021:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOn.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOn.fs.il.net472.bsl
new file mode 100644
index 00000000000..9fd9de44081
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOn.fs.il.net472.bsl
@@ -0,0 +1,108 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    .locals init (string V_0)
+    IL_0000:  ldstr      "A"
+    IL_0005:  stloc.0
+    IL_0006:  ldloc.0
+    IL_0007:  ldstr      "A"
+    IL_000c:  call       bool [netstandard]System.String::Equals(string,
+                                                                 string)
+    IL_0011:  brfalse.s  IL_001b
+
+    IL_0013:  call       void [runtime]System.Console::WriteLine()
+    IL_0018:  nop
+    IL_0019:  br.s       IL_0021
+
+    IL_001b:  call       void [runtime]System.Console::WriteLine()
+    IL_0020:  nop
+    IL_0021:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOn.fs.il.netcore .bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOn.fs.il.netcore .bsl
new file mode 100644
index 00000000000..21305bb0d17
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22f_RealInternalSignatureOn.fs.il.netcore .bsl	
@@ -0,0 +1,90 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly extern runtime { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  4
+    .locals init (string V_0)
+    IL_0000:  ldstr      "A"
+    IL_0005:  stloc.0
+    IL_0006:  ldloc.0
+    IL_0007:  ldstr      "A"
+    IL_000c:  call       bool [netstandard]System.String::Equals(string,
+                                                                 string)
+    IL_0011:  brfalse.s  IL_001b
+
+    IL_0013:  call       void [runtime]System.Console::WriteLine()
+    IL_0018:  nop
+    IL_0019:  br.s       IL_0021
+
+    IL_001b:  call       void [runtime]System.Console::WriteLine()
+    IL_0020:  nop
+    IL_0021:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g_RealInternalSignatureOff.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g_RealInternalSignatureOff.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g_RealInternalSignatureOff.fs.il.net472.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g.fs.il.net472.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g_RealInternalSignatureOff.fs.il.net472.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g_RealInternalSignatureOff.fs.il.netcore.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g.fs.il.netcore.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g_RealInternalSignatureOff.fs.il.netcore.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g_RealInternalSignatureOn.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g_RealInternalSignatureOn.fs
new file mode 100644
index 00000000000..4a90531ba66
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g_RealInternalSignatureOn.fs
@@ -0,0 +1,3 @@
+// #NoMono #NoMT #CodeGen #EmittedIL 
+#light
+if true then System.Console.WriteLine() else System.Console.WriteLine()
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g_RealInternalSignatureOn.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g_RealInternalSignatureOn.fs.il.net472.bsl
new file mode 100644
index 00000000000..a3b4e309f53
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g_RealInternalSignatureOn.fs.il.net472.bsl
@@ -0,0 +1,98 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ldc.i4.1
+    IL_0002:  brfalse.s  IL_000c
+
+    IL_0004:  call       void [runtime]System.Console::WriteLine()
+    IL_0009:  nop
+    IL_000a:  br.s       IL_0012
+
+    IL_000c:  call       void [runtime]System.Console::WriteLine()
+    IL_0011:  nop
+    IL_0012:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g_RealInternalSignatureOn.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g_RealInternalSignatureOn.fs.il.netcore.bsl
new file mode 100644
index 00000000000..986cc4ca1ce
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22g_RealInternalSignatureOn.fs.il.netcore.bsl
@@ -0,0 +1,99 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern runtime { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ldc.i4.1
+    IL_0002:  brfalse.s  IL_000c
+
+    IL_0004:  call       void [runtime]System.Console::WriteLine()
+    IL_0009:  nop
+    IL_000a:  br.s       IL_0012
+
+    IL_000c:  call       void [runtime]System.Console::WriteLine()
+    IL_0011:  nop
+    IL_0012:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOff.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOff.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOff.fs.il.net472.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h.fs.il.net472.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOff.fs.il.net472.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOff.fs.il.netcore.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h.fs.il.netcore.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOff.fs.il.netcore.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOn.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOn.fs
new file mode 100644
index 00000000000..5281549e50e
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOn.fs
@@ -0,0 +1,37 @@
+// #NoMono #NoMT #CodeGen #EmittedIL   
+#light
+let test1() =
+   try 
+      System.Console.WriteLine() 
+   with
+      // should not generate a filter
+      | _ -> System.Console.WriteLine()
+
+let test2() =
+   try 
+      System.Console.WriteLine() 
+   with
+      // should generate a filter
+      | :? System.ArgumentException -> System.Console.WriteLine()
+
+let test3() =
+   try 
+      System.Console.WriteLine() 
+   with
+      // should generate a filter
+      | :? System.ArgumentException as a -> System.Console.WriteLine(a.Message)
+
+let test4() =
+   try 
+      System.Console.WriteLine() 
+   with
+      // should generate a filter
+      | MatchFailureException ( msg, _, _) -> System.Console.WriteLine(msg)
+
+let test5() =
+   try 
+      System.Console.WriteLine() 
+   with
+      // should generate a filter
+      | :? System.ArgumentException as a -> System.Console.WriteLine(a.Message)
+      | MatchFailureException ( msg, _, _) -> System.Console.WriteLine(msg)
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOn.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOn.fs.il.bsl
new file mode 100644
index 00000000000..090680b761b
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOn.fs.il.bsl
@@ -0,0 +1,337 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern runtime { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  test1() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class [runtime]System.Exception V_0)
+    .try
+    {
+      IL_0000:  nop
+      IL_0001:  call       void [runtime]System.Console::WriteLine()
+      IL_0006:  leave.s    IL_0015
+
+    }  
+    catch [runtime]System.Object 
+    {
+      IL_0008:  castclass  [runtime]System.Exception
+      IL_000d:  stloc.0
+      IL_000e:  call       void [runtime]System.Console::WriteLine()
+      IL_0013:  leave.s    IL_0015
+
+    }  
+    IL_0015:  ret
+  } 
+
+  .method public static void  test2() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class [runtime]System.Exception V_0,
+             class [runtime]System.ArgumentException V_1,
+             class [runtime]System.Exception V_2,
+             class [runtime]System.ArgumentException V_3)
+    .try
+    {
+      IL_0000:  nop
+      IL_0001:  call       void [runtime]System.Console::WriteLine()
+      IL_0006:  leave.s    IL_0042
+
+    }  
+    filter
+    {
+      IL_0008:  castclass  [runtime]System.Exception
+      IL_000d:  stloc.0
+      IL_000e:  ldloc.0
+      IL_000f:  isinst     [runtime]System.ArgumentException
+      IL_0014:  stloc.1
+      IL_0015:  ldloc.1
+      IL_0016:  brfalse.s  IL_001c
+
+      IL_0018:  ldc.i4.1
+      IL_0019:  nop
+      IL_001a:  br.s       IL_001e
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  nop
+      IL_001e:  endfilter
+    }  
+    {  
+      IL_0020:  castclass  [runtime]System.Exception
+      IL_0025:  stloc.2
+      IL_0026:  ldloc.2
+      IL_0027:  isinst     [runtime]System.ArgumentException
+      IL_002c:  stloc.3
+      IL_002d:  ldloc.3
+      IL_002e:  brfalse.s  IL_0037
+
+      IL_0030:  call       void [runtime]System.Console::WriteLine()
+      IL_0035:  leave.s    IL_0042
+
+      IL_0037:  rethrow
+      IL_0039:  ldnull
+      IL_003a:  unbox.any  [FSharp.Core]Microsoft.FSharp.Core.Unit
+      IL_003f:  pop
+      IL_0040:  leave.s    IL_0042
+
+    }  
+    IL_0042:  ret
+  } 
+
+  .method public static void  test3() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class [runtime]System.Exception V_0,
+             class [runtime]System.ArgumentException V_1,
+             class [runtime]System.ArgumentException V_2,
+             class [runtime]System.Exception V_3,
+             class [runtime]System.ArgumentException V_4,
+             class [runtime]System.ArgumentException V_5)
+    .try
+    {
+      IL_0000:  nop
+      IL_0001:  call       void [runtime]System.Console::WriteLine()
+      IL_0006:  leave.s    IL_0051
+
+    }  
+    filter
+    {
+      IL_0008:  castclass  [runtime]System.Exception
+      IL_000d:  stloc.0
+      IL_000e:  ldloc.0
+      IL_000f:  isinst     [runtime]System.ArgumentException
+      IL_0014:  stloc.1
+      IL_0015:  ldloc.1
+      IL_0016:  brfalse.s  IL_001e
+
+      IL_0018:  ldloc.1
+      IL_0019:  stloc.2
+      IL_001a:  ldc.i4.1
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0020
+
+      IL_001e:  ldc.i4.0
+      IL_001f:  nop
+      IL_0020:  endfilter
+    }  
+    {  
+      IL_0022:  castclass  [runtime]System.Exception
+      IL_0027:  stloc.3
+      IL_0028:  ldloc.3
+      IL_0029:  isinst     [runtime]System.ArgumentException
+      IL_002e:  stloc.s    V_4
+      IL_0030:  ldloc.s    V_4
+      IL_0032:  brfalse.s  IL_0046
+
+      IL_0034:  ldloc.s    V_4
+      IL_0036:  stloc.s    V_5
+      IL_0038:  ldloc.s    V_5
+      IL_003a:  callvirt   instance string [runtime]System.Exception::get_Message()
+      IL_003f:  call       void [runtime]System.Console::WriteLine(string)
+      IL_0044:  leave.s    IL_0051
+
+      IL_0046:  rethrow
+      IL_0048:  ldnull
+      IL_0049:  unbox.any  [FSharp.Core]Microsoft.FSharp.Core.Unit
+      IL_004e:  pop
+      IL_004f:  leave.s    IL_0051
+
+    }  
+    IL_0051:  ret
+  } 
+
+  .method public static void  test4() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class [runtime]System.Exception V_0,
+             class [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException V_1,
+             string V_2,
+             class [runtime]System.Exception V_3,
+             class [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException V_4,
+             string V_5)
+    .try
+    {
+      IL_0000:  nop
+      IL_0001:  call       void [runtime]System.Console::WriteLine()
+      IL_0006:  leave.s    IL_005f
+
+    }  
+    filter
+    {
+      IL_0008:  castclass  [runtime]System.Exception
+      IL_000d:  stloc.0
+      IL_000e:  ldloc.0
+      IL_000f:  isinst     [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_0014:  stloc.1
+      IL_0015:  ldloc.1
+      IL_0016:  brfalse.s  IL_0028
+
+      IL_0018:  ldloc.0
+      IL_0019:  castclass  [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_001e:  call       instance string [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException::get_Data0()
+      IL_0023:  stloc.2
+      IL_0024:  ldc.i4.1
+      IL_0025:  nop
+      IL_0026:  br.s       IL_002a
+
+      IL_0028:  ldc.i4.0
+      IL_0029:  nop
+      IL_002a:  endfilter
+    }  
+    {  
+      IL_002c:  castclass  [runtime]System.Exception
+      IL_0031:  stloc.3
+      IL_0032:  ldloc.3
+      IL_0033:  isinst     [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_0038:  stloc.s    V_4
+      IL_003a:  ldloc.s    V_4
+      IL_003c:  brfalse.s  IL_0054
+
+      IL_003e:  ldloc.3
+      IL_003f:  castclass  [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_0044:  call       instance string [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException::get_Data0()
+      IL_0049:  stloc.s    V_5
+      IL_004b:  ldloc.s    V_5
+      IL_004d:  call       void [runtime]System.Console::WriteLine(string)
+      IL_0052:  leave.s    IL_005f
+
+      IL_0054:  rethrow
+      IL_0056:  ldnull
+      IL_0057:  unbox.any  [FSharp.Core]Microsoft.FSharp.Core.Unit
+      IL_005c:  pop
+      IL_005d:  leave.s    IL_005f
+
+    }  
+    IL_005f:  ret
+  } 
+
+  .method public static void  test5() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class [runtime]System.Exception V_0,
+             object V_1,
+             object V_2,
+             class [runtime]System.ArgumentException V_3,
+             string V_4)
+    .try
+    {
+      IL_0000:  nop
+      IL_0001:  call       void [runtime]System.Console::WriteLine()
+      IL_0006:  leave.s    IL_005f
+
+    }  
+    catch [runtime]System.Object 
+    {
+      IL_0008:  castclass  [runtime]System.Exception
+      IL_000d:  stloc.0
+      IL_000e:  ldloc.0
+      IL_000f:  stloc.1
+      IL_0010:  ldloc.1
+      IL_0011:  isinst     [runtime]System.ArgumentException
+      IL_0016:  ldnull
+      IL_0017:  cgt.un
+      IL_0019:  brtrue.s   IL_002a
+
+      IL_001b:  ldloc.0
+      IL_001c:  stloc.2
+      IL_001d:  ldloc.2
+      IL_001e:  isinst     [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_0023:  ldnull
+      IL_0024:  cgt.un
+      IL_0026:  brfalse.s  IL_0054
+
+      IL_0028:  br.s       IL_003e
+
+      IL_002a:  ldloc.0
+      IL_002b:  unbox.any  [runtime]System.ArgumentException
+      IL_0030:  stloc.3
+      IL_0031:  ldloc.3
+      IL_0032:  callvirt   instance string [runtime]System.Exception::get_Message()
+      IL_0037:  call       void [runtime]System.Console::WriteLine(string)
+      IL_003c:  leave.s    IL_005f
+
+      IL_003e:  ldloc.0
+      IL_003f:  castclass  [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_0044:  call       instance string [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException::get_Data0()
+      IL_0049:  stloc.s    V_4
+      IL_004b:  ldloc.s    V_4
+      IL_004d:  call       void [runtime]System.Console::WriteLine(string)
+      IL_0052:  leave.s    IL_005f
+
+      IL_0054:  rethrow
+      IL_0056:  ldnull
+      IL_0057:  unbox.any  [FSharp.Core]Microsoft.FSharp.Core.Unit
+      IL_005c:  pop
+      IL_005d:  leave.s    IL_005f
+
+    }  
+    IL_005f:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOn.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOn.fs.il.net472.bsl
new file mode 100644
index 00000000000..c8c4283bcf3
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOn.fs.il.net472.bsl
@@ -0,0 +1,336 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  test1() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class [runtime]System.Exception V_0)
+    .try
+    {
+      IL_0000:  nop
+      IL_0001:  call       void [runtime]System.Console::WriteLine()
+      IL_0006:  leave.s    IL_0015
+
+    }  
+    catch [runtime]System.Object 
+    {
+      IL_0008:  castclass  [runtime]System.Exception
+      IL_000d:  stloc.0
+      IL_000e:  call       void [runtime]System.Console::WriteLine()
+      IL_0013:  leave.s    IL_0015
+
+    }  
+    IL_0015:  ret
+  } 
+
+  .method public static void  test2() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class [runtime]System.Exception V_0,
+             class [runtime]System.ArgumentException V_1,
+             class [runtime]System.Exception V_2,
+             class [runtime]System.ArgumentException V_3)
+    .try
+    {
+      IL_0000:  nop
+      IL_0001:  call       void [runtime]System.Console::WriteLine()
+      IL_0006:  leave.s    IL_0042
+
+    }  
+    filter
+    {
+      IL_0008:  castclass  [runtime]System.Exception
+      IL_000d:  stloc.0
+      IL_000e:  ldloc.0
+      IL_000f:  isinst     [runtime]System.ArgumentException
+      IL_0014:  stloc.1
+      IL_0015:  ldloc.1
+      IL_0016:  brfalse.s  IL_001c
+
+      IL_0018:  ldc.i4.1
+      IL_0019:  nop
+      IL_001a:  br.s       IL_001e
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  nop
+      IL_001e:  endfilter
+    }  
+    {  
+      IL_0020:  castclass  [runtime]System.Exception
+      IL_0025:  stloc.2
+      IL_0026:  ldloc.2
+      IL_0027:  isinst     [runtime]System.ArgumentException
+      IL_002c:  stloc.3
+      IL_002d:  ldloc.3
+      IL_002e:  brfalse.s  IL_0037
+
+      IL_0030:  call       void [runtime]System.Console::WriteLine()
+      IL_0035:  leave.s    IL_0042
+
+      IL_0037:  rethrow
+      IL_0039:  ldnull
+      IL_003a:  unbox.any  [FSharp.Core]Microsoft.FSharp.Core.Unit
+      IL_003f:  pop
+      IL_0040:  leave.s    IL_0042
+
+    }  
+    IL_0042:  ret
+  } 
+
+  .method public static void  test3() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class [runtime]System.Exception V_0,
+             class [runtime]System.ArgumentException V_1,
+             class [runtime]System.ArgumentException V_2,
+             class [runtime]System.Exception V_3,
+             class [runtime]System.ArgumentException V_4,
+             class [runtime]System.ArgumentException V_5)
+    .try
+    {
+      IL_0000:  nop
+      IL_0001:  call       void [runtime]System.Console::WriteLine()
+      IL_0006:  leave.s    IL_0051
+
+    }  
+    filter
+    {
+      IL_0008:  castclass  [runtime]System.Exception
+      IL_000d:  stloc.0
+      IL_000e:  ldloc.0
+      IL_000f:  isinst     [runtime]System.ArgumentException
+      IL_0014:  stloc.1
+      IL_0015:  ldloc.1
+      IL_0016:  brfalse.s  IL_001e
+
+      IL_0018:  ldloc.1
+      IL_0019:  stloc.2
+      IL_001a:  ldc.i4.1
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0020
+
+      IL_001e:  ldc.i4.0
+      IL_001f:  nop
+      IL_0020:  endfilter
+    }  
+    {  
+      IL_0022:  castclass  [runtime]System.Exception
+      IL_0027:  stloc.3
+      IL_0028:  ldloc.3
+      IL_0029:  isinst     [runtime]System.ArgumentException
+      IL_002e:  stloc.s    V_4
+      IL_0030:  ldloc.s    V_4
+      IL_0032:  brfalse.s  IL_0046
+
+      IL_0034:  ldloc.s    V_4
+      IL_0036:  stloc.s    V_5
+      IL_0038:  ldloc.s    V_5
+      IL_003a:  callvirt   instance string [runtime]System.Exception::get_Message()
+      IL_003f:  call       void [runtime]System.Console::WriteLine(string)
+      IL_0044:  leave.s    IL_0051
+
+      IL_0046:  rethrow
+      IL_0048:  ldnull
+      IL_0049:  unbox.any  [FSharp.Core]Microsoft.FSharp.Core.Unit
+      IL_004e:  pop
+      IL_004f:  leave.s    IL_0051
+
+    }  
+    IL_0051:  ret
+  } 
+
+  .method public static void  test4() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class [runtime]System.Exception V_0,
+             class [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException V_1,
+             string V_2,
+             class [runtime]System.Exception V_3,
+             class [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException V_4,
+             string V_5)
+    .try
+    {
+      IL_0000:  nop
+      IL_0001:  call       void [runtime]System.Console::WriteLine()
+      IL_0006:  leave.s    IL_005f
+
+    }  
+    filter
+    {
+      IL_0008:  castclass  [runtime]System.Exception
+      IL_000d:  stloc.0
+      IL_000e:  ldloc.0
+      IL_000f:  isinst     [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_0014:  stloc.1
+      IL_0015:  ldloc.1
+      IL_0016:  brfalse.s  IL_0028
+
+      IL_0018:  ldloc.0
+      IL_0019:  castclass  [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_001e:  call       instance string [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException::get_Data0()
+      IL_0023:  stloc.2
+      IL_0024:  ldc.i4.1
+      IL_0025:  nop
+      IL_0026:  br.s       IL_002a
+
+      IL_0028:  ldc.i4.0
+      IL_0029:  nop
+      IL_002a:  endfilter
+    }  
+    {  
+      IL_002c:  castclass  [runtime]System.Exception
+      IL_0031:  stloc.3
+      IL_0032:  ldloc.3
+      IL_0033:  isinst     [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_0038:  stloc.s    V_4
+      IL_003a:  ldloc.s    V_4
+      IL_003c:  brfalse.s  IL_0054
+
+      IL_003e:  ldloc.3
+      IL_003f:  castclass  [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_0044:  call       instance string [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException::get_Data0()
+      IL_0049:  stloc.s    V_5
+      IL_004b:  ldloc.s    V_5
+      IL_004d:  call       void [runtime]System.Console::WriteLine(string)
+      IL_0052:  leave.s    IL_005f
+
+      IL_0054:  rethrow
+      IL_0056:  ldnull
+      IL_0057:  unbox.any  [FSharp.Core]Microsoft.FSharp.Core.Unit
+      IL_005c:  pop
+      IL_005d:  leave.s    IL_005f
+
+    }  
+    IL_005f:  ret
+  } 
+
+  .method public static void  test5() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class [runtime]System.Exception V_0,
+             object V_1,
+             object V_2,
+             class [runtime]System.ArgumentException V_3,
+             string V_4)
+    .try
+    {
+      IL_0000:  nop
+      IL_0001:  call       void [runtime]System.Console::WriteLine()
+      IL_0006:  leave.s    IL_005f
+
+    }  
+    catch [runtime]System.Object 
+    {
+      IL_0008:  castclass  [runtime]System.Exception
+      IL_000d:  stloc.0
+      IL_000e:  ldloc.0
+      IL_000f:  stloc.1
+      IL_0010:  ldloc.1
+      IL_0011:  isinst     [runtime]System.ArgumentException
+      IL_0016:  ldnull
+      IL_0017:  cgt.un
+      IL_0019:  brtrue.s   IL_002a
+
+      IL_001b:  ldloc.0
+      IL_001c:  stloc.2
+      IL_001d:  ldloc.2
+      IL_001e:  isinst     [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_0023:  ldnull
+      IL_0024:  cgt.un
+      IL_0026:  brfalse.s  IL_0054
+
+      IL_0028:  br.s       IL_003e
+
+      IL_002a:  ldloc.0
+      IL_002b:  unbox.any  [runtime]System.ArgumentException
+      IL_0030:  stloc.3
+      IL_0031:  ldloc.3
+      IL_0032:  callvirt   instance string [runtime]System.Exception::get_Message()
+      IL_0037:  call       void [runtime]System.Console::WriteLine(string)
+      IL_003c:  leave.s    IL_005f
+
+      IL_003e:  ldloc.0
+      IL_003f:  castclass  [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_0044:  call       instance string [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException::get_Data0()
+      IL_0049:  stloc.s    V_4
+      IL_004b:  ldloc.s    V_4
+      IL_004d:  call       void [runtime]System.Console::WriteLine(string)
+      IL_0052:  leave.s    IL_005f
+
+      IL_0054:  rethrow
+      IL_0056:  ldnull
+      IL_0057:  unbox.any  [FSharp.Core]Microsoft.FSharp.Core.Unit
+      IL_005c:  pop
+      IL_005d:  leave.s    IL_005f
+
+    }  
+    IL_005f:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOn.fs.il.netcore .bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOn.fs.il.netcore .bsl
new file mode 100644
index 00000000000..090680b761b
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunction22h_RealInternalSignatureOn.fs.il.netcore .bsl	
@@ -0,0 +1,337 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern runtime { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method public static void  test1() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class [runtime]System.Exception V_0)
+    .try
+    {
+      IL_0000:  nop
+      IL_0001:  call       void [runtime]System.Console::WriteLine()
+      IL_0006:  leave.s    IL_0015
+
+    }  
+    catch [runtime]System.Object 
+    {
+      IL_0008:  castclass  [runtime]System.Exception
+      IL_000d:  stloc.0
+      IL_000e:  call       void [runtime]System.Console::WriteLine()
+      IL_0013:  leave.s    IL_0015
+
+    }  
+    IL_0015:  ret
+  } 
+
+  .method public static void  test2() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class [runtime]System.Exception V_0,
+             class [runtime]System.ArgumentException V_1,
+             class [runtime]System.Exception V_2,
+             class [runtime]System.ArgumentException V_3)
+    .try
+    {
+      IL_0000:  nop
+      IL_0001:  call       void [runtime]System.Console::WriteLine()
+      IL_0006:  leave.s    IL_0042
+
+    }  
+    filter
+    {
+      IL_0008:  castclass  [runtime]System.Exception
+      IL_000d:  stloc.0
+      IL_000e:  ldloc.0
+      IL_000f:  isinst     [runtime]System.ArgumentException
+      IL_0014:  stloc.1
+      IL_0015:  ldloc.1
+      IL_0016:  brfalse.s  IL_001c
+
+      IL_0018:  ldc.i4.1
+      IL_0019:  nop
+      IL_001a:  br.s       IL_001e
+
+      IL_001c:  ldc.i4.0
+      IL_001d:  nop
+      IL_001e:  endfilter
+    }  
+    {  
+      IL_0020:  castclass  [runtime]System.Exception
+      IL_0025:  stloc.2
+      IL_0026:  ldloc.2
+      IL_0027:  isinst     [runtime]System.ArgumentException
+      IL_002c:  stloc.3
+      IL_002d:  ldloc.3
+      IL_002e:  brfalse.s  IL_0037
+
+      IL_0030:  call       void [runtime]System.Console::WriteLine()
+      IL_0035:  leave.s    IL_0042
+
+      IL_0037:  rethrow
+      IL_0039:  ldnull
+      IL_003a:  unbox.any  [FSharp.Core]Microsoft.FSharp.Core.Unit
+      IL_003f:  pop
+      IL_0040:  leave.s    IL_0042
+
+    }  
+    IL_0042:  ret
+  } 
+
+  .method public static void  test3() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class [runtime]System.Exception V_0,
+             class [runtime]System.ArgumentException V_1,
+             class [runtime]System.ArgumentException V_2,
+             class [runtime]System.Exception V_3,
+             class [runtime]System.ArgumentException V_4,
+             class [runtime]System.ArgumentException V_5)
+    .try
+    {
+      IL_0000:  nop
+      IL_0001:  call       void [runtime]System.Console::WriteLine()
+      IL_0006:  leave.s    IL_0051
+
+    }  
+    filter
+    {
+      IL_0008:  castclass  [runtime]System.Exception
+      IL_000d:  stloc.0
+      IL_000e:  ldloc.0
+      IL_000f:  isinst     [runtime]System.ArgumentException
+      IL_0014:  stloc.1
+      IL_0015:  ldloc.1
+      IL_0016:  brfalse.s  IL_001e
+
+      IL_0018:  ldloc.1
+      IL_0019:  stloc.2
+      IL_001a:  ldc.i4.1
+      IL_001b:  nop
+      IL_001c:  br.s       IL_0020
+
+      IL_001e:  ldc.i4.0
+      IL_001f:  nop
+      IL_0020:  endfilter
+    }  
+    {  
+      IL_0022:  castclass  [runtime]System.Exception
+      IL_0027:  stloc.3
+      IL_0028:  ldloc.3
+      IL_0029:  isinst     [runtime]System.ArgumentException
+      IL_002e:  stloc.s    V_4
+      IL_0030:  ldloc.s    V_4
+      IL_0032:  brfalse.s  IL_0046
+
+      IL_0034:  ldloc.s    V_4
+      IL_0036:  stloc.s    V_5
+      IL_0038:  ldloc.s    V_5
+      IL_003a:  callvirt   instance string [runtime]System.Exception::get_Message()
+      IL_003f:  call       void [runtime]System.Console::WriteLine(string)
+      IL_0044:  leave.s    IL_0051
+
+      IL_0046:  rethrow
+      IL_0048:  ldnull
+      IL_0049:  unbox.any  [FSharp.Core]Microsoft.FSharp.Core.Unit
+      IL_004e:  pop
+      IL_004f:  leave.s    IL_0051
+
+    }  
+    IL_0051:  ret
+  } 
+
+  .method public static void  test4() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class [runtime]System.Exception V_0,
+             class [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException V_1,
+             string V_2,
+             class [runtime]System.Exception V_3,
+             class [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException V_4,
+             string V_5)
+    .try
+    {
+      IL_0000:  nop
+      IL_0001:  call       void [runtime]System.Console::WriteLine()
+      IL_0006:  leave.s    IL_005f
+
+    }  
+    filter
+    {
+      IL_0008:  castclass  [runtime]System.Exception
+      IL_000d:  stloc.0
+      IL_000e:  ldloc.0
+      IL_000f:  isinst     [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_0014:  stloc.1
+      IL_0015:  ldloc.1
+      IL_0016:  brfalse.s  IL_0028
+
+      IL_0018:  ldloc.0
+      IL_0019:  castclass  [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_001e:  call       instance string [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException::get_Data0()
+      IL_0023:  stloc.2
+      IL_0024:  ldc.i4.1
+      IL_0025:  nop
+      IL_0026:  br.s       IL_002a
+
+      IL_0028:  ldc.i4.0
+      IL_0029:  nop
+      IL_002a:  endfilter
+    }  
+    {  
+      IL_002c:  castclass  [runtime]System.Exception
+      IL_0031:  stloc.3
+      IL_0032:  ldloc.3
+      IL_0033:  isinst     [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_0038:  stloc.s    V_4
+      IL_003a:  ldloc.s    V_4
+      IL_003c:  brfalse.s  IL_0054
+
+      IL_003e:  ldloc.3
+      IL_003f:  castclass  [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_0044:  call       instance string [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException::get_Data0()
+      IL_0049:  stloc.s    V_5
+      IL_004b:  ldloc.s    V_5
+      IL_004d:  call       void [runtime]System.Console::WriteLine(string)
+      IL_0052:  leave.s    IL_005f
+
+      IL_0054:  rethrow
+      IL_0056:  ldnull
+      IL_0057:  unbox.any  [FSharp.Core]Microsoft.FSharp.Core.Unit
+      IL_005c:  pop
+      IL_005d:  leave.s    IL_005f
+
+    }  
+    IL_005f:  ret
+  } 
+
+  .method public static void  test5() cil managed
+  {
+    
+    .maxstack  3
+    .locals init (class [runtime]System.Exception V_0,
+             object V_1,
+             object V_2,
+             class [runtime]System.ArgumentException V_3,
+             string V_4)
+    .try
+    {
+      IL_0000:  nop
+      IL_0001:  call       void [runtime]System.Console::WriteLine()
+      IL_0006:  leave.s    IL_005f
+
+    }  
+    catch [runtime]System.Object 
+    {
+      IL_0008:  castclass  [runtime]System.Exception
+      IL_000d:  stloc.0
+      IL_000e:  ldloc.0
+      IL_000f:  stloc.1
+      IL_0010:  ldloc.1
+      IL_0011:  isinst     [runtime]System.ArgumentException
+      IL_0016:  ldnull
+      IL_0017:  cgt.un
+      IL_0019:  brtrue.s   IL_002a
+
+      IL_001b:  ldloc.0
+      IL_001c:  stloc.2
+      IL_001d:  ldloc.2
+      IL_001e:  isinst     [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_0023:  ldnull
+      IL_0024:  cgt.un
+      IL_0026:  brfalse.s  IL_0054
+
+      IL_0028:  br.s       IL_003e
+
+      IL_002a:  ldloc.0
+      IL_002b:  unbox.any  [runtime]System.ArgumentException
+      IL_0030:  stloc.3
+      IL_0031:  ldloc.3
+      IL_0032:  callvirt   instance string [runtime]System.Exception::get_Message()
+      IL_0037:  call       void [runtime]System.Console::WriteLine(string)
+      IL_003c:  leave.s    IL_005f
+
+      IL_003e:  ldloc.0
+      IL_003f:  castclass  [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException
+      IL_0044:  call       instance string [FSharp.Core]Microsoft.FSharp.Core.MatchFailureException::get_Data0()
+      IL_0049:  stloc.s    V_4
+      IL_004b:  ldloc.s    V_4
+      IL_004d:  call       void [runtime]System.Console::WriteLine(string)
+      IL_0052:  leave.s    IL_005f
+
+      IL_0054:  rethrow
+      IL_0056:  ldnull
+      IL_0057:  unbox.any  [FSharp.Core]Microsoft.FSharp.Core.Unit
+      IL_005c:  pop
+      IL_005d:  leave.s    IL_005f
+
+    }  
+    IL_005f:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunctions.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunctions.fs
index 4b976530e9e..9b2ce64194e 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunctions.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/TestFunctions.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open Xunit
 open System.IO
@@ -117,9 +117,17 @@ module TestFunctions =
         |> verifyCompilation
 
     //SOURCE=TestFunction09b4.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction09b4.exe"	# TestFunction09b4.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction09b4.fs"|])>]
-    let ``TestFunction09b4_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction09b4_RealInternalSignatureOff.fs"|])>]
+    let ``TestFunction09b4_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    //SOURCE=TestFunction09b4.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction09b4.exe"	# TestFunction09b4.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction09b4_RealInternalSignatureOn.fs"|])>]
+    let ``TestFunction09b4_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     //SOURCE=TestFunction10.fs  SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction10.exe"	# TestFunction10.fs -
@@ -195,51 +203,115 @@ module TestFunctions =
         |> verifyCompilation
 
     //SOURCE=TestFunction22.fs    SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction22.exe"	# TestFunction22.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22.fs"|])>]
-    let ``TestFunction22_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22_RealInternalSignatureOff.fs"|])>]
+    let ``TestFunction22_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    //SOURCE=TestFunction22.fs    SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction22.exe"	# TestFunction22.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22_RealInternalSignatureOn.fs"|])>]
+    let ``TestFunction22_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     //SOURCE=TestFunction22b.fs   SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction22b.exe"	# TestFunction22b.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22b.fs"|])>]
-    let ``TestFunction22b_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22b_RealInternalSignatureOff.fs"|])>]
+    let ``TestFunction22b_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    //SOURCE=TestFunction22b.fs   SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction22b.exe"	# TestFunction22b.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22b_RealInternalSignatureOn.fs"|])>]
+    let ``TestFunction22b_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    //SOURCE=TestFunction22c.fs   SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction22c.exe"	# TestFunction22c.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22c_RealInternalSignatureOff.fs"|])>]
+    let ``TestFunction22c_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     //SOURCE=TestFunction22c.fs   SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction22c.exe"	# TestFunction22c.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22c.fs"|])>]
-    let ``TestFunction22c_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22c_RealInternalSignatureOn.fs"|])>]
+    let ``TestFunction22c_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     //SOURCE=TestFunction22d.fs   SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction22d.exe"	# TestFunction22d.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22d.fs"|])>]
-    let ``TestFunction22d_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22d_RealInternalSignatureOff.fs"|])>]
+    let ``TestFunction22d_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    //SOURCE=TestFunction22d.fs   SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction22d.exe"	# TestFunction22d.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22d_RealInternalSignatureOn.fs"|])>]
+    let ``TestFunction22d_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    //SOURCE=TestFunction22e.fs   SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction22e.exe"	# TestFunction22e.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22e_RealInternalSignatureOff.fs"|])>]
+    let ``TestFunction22e_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     //SOURCE=TestFunction22e.fs   SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction22e.exe"	# TestFunction22e.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22e.fs"|])>]
-    let ``TestFunction22e_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22e_RealInternalSignatureOn.fs"|])>]
+    let ``TestFunction22e_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    //SOURCE=TestFunction22f.fs   SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction22f.exe"	# TestFunction22f.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22f_RealInternalSignatureOff.fs"|])>]
+    let ``TestFunction22f_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     //SOURCE=TestFunction22f.fs   SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction22f.exe"	# TestFunction22f.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22f.fs"|])>]
-    let ``TestFunction22f_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22f_RealInternalSignatureOn.fs"|])>]
+    let ``TestFunction22f_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     //SOURCE=TestFunction22g.fs   SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction22g.exe"	# TestFunction22g.fs
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22g.fs"|])>]
-    let ``TestFunction22g_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22g_RealInternalSignatureOff.fs"|])>]
+    let ``TestFunction22g_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    //SOURCE=TestFunction22g.fs   SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction22g.exe"	# TestFunction22g.fs
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22g_RealInternalSignatureOn.fs"|])>]
+    let ``TestFunction22g_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    //SOURCE=TestFunction22h.fs   SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction22h.exe"	# TestFunction22h.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22h_RealInternalSignatureOff.fs"|])>]
+    let ``TestFunction22h_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     //SOURCE=TestFunction22h.fs   SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction22h.exe"	# TestFunction22h.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22h.fs"|])>]
-    let ``TestFunction22h_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TestFunction22h_RealInternalSignatureOn.fs"|])>]
+    let ``TestFunction22h_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     //SOURCE=TestFunction23.fs  SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TestFunction23.exe"	# TestFunction23.fs -
@@ -256,27 +328,59 @@ module TestFunctions =
         |> verifyCompilation
 
     // Verify IL 13043
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Verify13043.fs"|])>]
-    let ``Verify13043_il`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Verify13043_RealInternalSignatureOff.fs"|])>]
+    let ``Verify13043_RealInternalSignatureOff_fs`` compilation =
         compilation
         |> withDebug
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
+    // Verify IL 13043
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Verify13043_RealInternalSignatureOn.fs"|])>]
+    let ``Verify13043_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withDebug
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    // Verify Execution 13043 run it built not optimized with debug
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Verify13043_RealInternalSignatureOff.fs"|])>]
+    let ``Verify13043_Verify13043_RealInternalSignatureOff_execution_noopt`` compilation =
+        compilation
+        |> withDebug
+        |> withRealInternalSignatureOff
+        |> verifyCompileAndRun
+        |> shouldSucceed
+
     // Verify Execution 13043 run it built not optimized with debug
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Verify13043.fs"|])>]
-    let ``Verify13043_execution_noopt`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Verify13043_RealInternalSignatureOn.fs"|])>]
+    let ``Verify13043_Verify13043_RealInternalSignatureOn_execution_noopt`` compilation =
         compilation
         |> withDebug
+        |> withRealInternalSignatureOn
         |> verifyCompileAndRun
         |> shouldSucceed
 
     // Verify Execution 13043 --- run it built optimized no debug
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Verify13043.fs"|])>]
-    let ``Verify13043_execution_opt`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Verify13043_RealInternalSignatureOff.fs"|])>]
+    let ``Verify13043_RealInternalSignatureOff_execution_opt`` compilation =
+        compilation
+        |> asExe
+        |> withOptions [ "--test:EmitFeeFeeAs100001"; "--nowarn:988"; "--nowarn:3370"]
+        |> withOptimize
+        |> withNoDebug
+        |> withRealInternalSignatureOff
+        |> compileAndRun
+        |> shouldSucceed
+
+    // Verify Execution 13043 --- run it built optimized no debug
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Verify13043_RealInternalSignatureOn.fs"|])>]
+    let ``Verify13043_RealInternalSignatureOn_execution_opt`` compilation =
         compilation
         |> asExe
         |> withOptions [ "--test:EmitFeeFeeAs100001"; "--nowarn:988"; "--nowarn:3370"]
         |> withOptimize
         |> withNoDebug
+        |> withRealInternalSignatureOn
         |> compileAndRun
         |> shouldSucceed
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOff.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOff.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043.fs.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOff.fs.il.debug.bsl
similarity index 84%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043.fs.il.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOff.fs.il.debug.bsl
index db118790e53..179b6da5425 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043.fs.il.debug.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOff.fs.il.debug.bsl
@@ -39,7 +39,7 @@
 
 
 
-.class public abstract auto ansi sealed assembly
+.class public abstract auto ansi sealed Verify13043
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
@@ -47,8 +47,7 @@
          extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>
   {
     .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -58,12 +57,11 @@
       IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor()
       IL_0006:  ldarg.0
       IL_0007:  ldarg.1
-      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> assembly/f@8::condition
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> Verify13043/f@8::condition
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> l) cil managed
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> l) cil managed
     {
       
       .maxstack  6
@@ -92,7 +90,7 @@
       IL_0021:  stloc.3
       IL_0022:  nop
       IL_0023:  ldarg.0
-      IL_0024:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> assembly/f@8::condition
+      IL_0024:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> Verify13043/f@8::condition
       IL_0029:  ldloc.3
       IL_002a:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::Invoke(!0)
       IL_002f:  brfalse.s  IL_0036
@@ -114,8 +112,7 @@
          extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>
   {
     .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -125,12 +122,11 @@
       IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor()
       IL_0006:  ldarg.0
       IL_0007:  ldarg.1
-      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> assembly/'f@27-1'::condition
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> Verify13043/'f@27-1'::condition
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> _arg1) cil managed
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> _arg1) cil managed
     {
       
       .maxstack  6
@@ -159,7 +155,7 @@
       IL_0021:  stloc.3
       IL_0022:  nop
       IL_0023:  ldarg.0
-      IL_0024:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> assembly/'f@27-1'::condition
+      IL_0024:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> Verify13043/'f@27-1'::condition
       IL_0029:  ldloc.3
       IL_002a:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::Invoke(!0)
       IL_002f:  brfalse.s  IL_0036
@@ -180,9 +176,8 @@
   .class auto ansi serializable sealed nested assembly beforefieldinit matchResult@38
          extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
   {
-    .field static assembly initonly class assembly/matchResult@38 @_instance
-    .method assembly specialname rtspecialname 
-            instance void  .ctor() cil managed
+    .field static assembly initonly class Verify13043/matchResult@38 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -193,23 +188,21 @@
       IL_0006:  ret
     } 
 
-    .method public strict virtual instance bool 
-            Invoke(int32 n) cil managed
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
     {
       
       .maxstack  8
       IL_0000:  ldarg.1
-      IL_0001:  call       bool assembly::condition(int32)
+      IL_0001:  call       bool Verify13043::condition(int32)
       IL_0006:  ret
     } 
 
-    .method private specialname rtspecialname static 
-            void  .cctor() cil managed
+    .method private specialname rtspecialname static void  .cctor() cil managed
     {
       
       .maxstack  10
-      IL_0000:  newobj     instance void assembly/matchResult@38::.ctor()
-      IL_0005:  stsfld     class assembly/matchResult@38 assembly/matchResult@38::@_instance
+      IL_0000:  newobj     instance void Verify13043/matchResult@38::.ctor()
+      IL_0005:  stsfld     class Verify13043/matchResult@38 Verify13043/matchResult@38::@_instance
       IL_000a:  ret
     } 
 
@@ -218,9 +211,8 @@
   .class auto ansi serializable sealed nested assembly beforefieldinit functionResult@43
          extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
   {
-    .field static assembly initonly class assembly/functionResult@43 @_instance
-    .method assembly specialname rtspecialname 
-            instance void  .ctor() cil managed
+    .field static assembly initonly class Verify13043/functionResult@43 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -231,34 +223,31 @@
       IL_0006:  ret
     } 
 
-    .method public strict virtual instance bool 
-            Invoke(int32 n) cil managed
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
     {
       
       .maxstack  8
       IL_0000:  ldarg.1
-      IL_0001:  call       bool assembly::condition(int32)
+      IL_0001:  call       bool Verify13043::condition(int32)
       IL_0006:  ret
     } 
 
-    .method private specialname rtspecialname static 
-            void  .cctor() cil managed
+    .method private specialname rtspecialname static void  .cctor() cil managed
     {
       
       .maxstack  10
-      IL_0000:  newobj     instance void assembly/functionResult@43::.ctor()
-      IL_0005:  stsfld     class assembly/functionResult@43 assembly/functionResult@43::@_instance
+      IL_0000:  newobj     instance void Verify13043/functionResult@43::.ctor()
+      IL_0005:  stsfld     class Verify13043/functionResult@43 Verify13043/functionResult@43::@_instance
       IL_000a:  ret
     } 
 
   } 
 
-  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
-          get_list() cil managed
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_list() cil managed
   {
     
     .maxstack  8
-    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$assembly::list@3
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$Verify13043::list@3
     IL_0005:  ret
   } 
 
@@ -281,7 +270,7 @@
     .maxstack  4
     .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>> V_0)
     IL_0000:  ldarg.0
-    IL_0001:  newobj     instance void assembly/f@8::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>)
+    IL_0001:  newobj     instance void Verify13043/f@8::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>)
     IL_0006:  stloc.0
     IL_0007:  ldloc.0
     IL_0008:  ldarg.1
@@ -299,7 +288,7 @@
     .maxstack  4
     .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>> V_0)
     IL_0000:  ldarg.0
-    IL_0001:  newobj     instance void assembly/'f@27-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>)
+    IL_0001:  newobj     instance void Verify13043/'f@27-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>)
     IL_0006:  stloc.0
     IL_0007:  ldloc.0
     IL_0008:  ldarg.1
@@ -308,21 +297,19 @@
     IL_0010:  ret
   } 
 
-  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
-          get_matchResult() cil managed
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_matchResult() cil managed
   {
     
     .maxstack  8
-    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$assembly::matchResult@38
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$Verify13043::matchResult@38
     IL_0005:  ret
   } 
 
-  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
-          get_functionResult() cil managed
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_functionResult() cil managed
   {
     
     .maxstack  8
-    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$assembly::functionResult@43
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$Verify13043::functionResult@43
     IL_0005:  ret
   } 
 
@@ -330,23 +317,23 @@
           list()
   {
     .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
-    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_list()
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_list()
   } 
   .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
           matchResult()
   {
     .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
-    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_matchResult()
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_matchResult()
   } 
   .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
           functionResult()
   {
     .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
-    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_functionResult()
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_functionResult()
   } 
 } 
 
-.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Verify13043
        extends [runtime]System.Object
 {
   .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> list@3
@@ -378,32 +365,32 @@
     IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
     IL_0017:  dup
-    IL_0018:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$assembly::list@3
+    IL_0018:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$Verify13043::list@3
     IL_001d:  stloc.0
-    IL_001e:  ldsfld     class assembly/matchResult@38 assembly/matchResult@38::@_instance
-    IL_0023:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_list()
-    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::dropWhileWithMatch(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>,
+    IL_001e:  ldsfld     class Verify13043/matchResult@38 Verify13043/matchResult@38::@_instance
+    IL_0023:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_list()
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::dropWhileWithMatch(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>,
                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
     IL_002d:  dup
-    IL_002e:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$assembly::matchResult@38
+    IL_002e:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$Verify13043::matchResult@38
     IL_0033:  stloc.1
     IL_0034:  ldstr      "Match: %A"
     IL_0039:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor(string)
     IL_003e:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
-    IL_0043:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_matchResult()
+    IL_0043:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_matchResult()
     IL_0048:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
     IL_004d:  pop
-    IL_004e:  ldsfld     class assembly/functionResult@43 assembly/functionResult@43::@_instance
-    IL_0053:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_list()
-    IL_0058:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::dropWhileWithFunction(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>,
+    IL_004e:  ldsfld     class Verify13043/functionResult@43 Verify13043/functionResult@43::@_instance
+    IL_0053:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_list()
+    IL_0058:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::dropWhileWithFunction(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>,
                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
     IL_005d:  dup
-    IL_005e:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$assembly::functionResult@43
+    IL_005e:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$Verify13043::functionResult@43
     IL_0063:  stloc.2
     IL_0064:  ldstr      "Function: %A"
     IL_0069:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor(string)
     IL_006e:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
-    IL_0073:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_functionResult()
+    IL_0073:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_functionResult()
     IL_0078:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
     IL_007d:  pop
     IL_007e:  ret
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043.fs.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOff.fs.il.release.bsl
similarity index 84%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043.fs.il.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOff.fs.il.release.bsl
index db118790e53..179b6da5425 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043.fs.il.release.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOff.fs.il.release.bsl
@@ -39,7 +39,7 @@
 
 
 
-.class public abstract auto ansi sealed assembly
+.class public abstract auto ansi sealed Verify13043
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
@@ -47,8 +47,7 @@
          extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>
   {
     .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -58,12 +57,11 @@
       IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor()
       IL_0006:  ldarg.0
       IL_0007:  ldarg.1
-      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> assembly/f@8::condition
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> Verify13043/f@8::condition
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> l) cil managed
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> l) cil managed
     {
       
       .maxstack  6
@@ -92,7 +90,7 @@
       IL_0021:  stloc.3
       IL_0022:  nop
       IL_0023:  ldarg.0
-      IL_0024:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> assembly/f@8::condition
+      IL_0024:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> Verify13043/f@8::condition
       IL_0029:  ldloc.3
       IL_002a:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::Invoke(!0)
       IL_002f:  brfalse.s  IL_0036
@@ -114,8 +112,7 @@
          extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>
   {
     .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition
-    .method assembly specialname rtspecialname 
-            instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition) cil managed
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition) cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -125,12 +122,11 @@
       IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor()
       IL_0006:  ldarg.0
       IL_0007:  ldarg.1
-      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> assembly/'f@27-1'::condition
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> Verify13043/'f@27-1'::condition
       IL_000d:  ret
     } 
 
-    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
-            Invoke(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> _arg1) cil managed
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> _arg1) cil managed
     {
       
       .maxstack  6
@@ -159,7 +155,7 @@
       IL_0021:  stloc.3
       IL_0022:  nop
       IL_0023:  ldarg.0
-      IL_0024:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> assembly/'f@27-1'::condition
+      IL_0024:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> Verify13043/'f@27-1'::condition
       IL_0029:  ldloc.3
       IL_002a:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::Invoke(!0)
       IL_002f:  brfalse.s  IL_0036
@@ -180,9 +176,8 @@
   .class auto ansi serializable sealed nested assembly beforefieldinit matchResult@38
          extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
   {
-    .field static assembly initonly class assembly/matchResult@38 @_instance
-    .method assembly specialname rtspecialname 
-            instance void  .ctor() cil managed
+    .field static assembly initonly class Verify13043/matchResult@38 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -193,23 +188,21 @@
       IL_0006:  ret
     } 
 
-    .method public strict virtual instance bool 
-            Invoke(int32 n) cil managed
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
     {
       
       .maxstack  8
       IL_0000:  ldarg.1
-      IL_0001:  call       bool assembly::condition(int32)
+      IL_0001:  call       bool Verify13043::condition(int32)
       IL_0006:  ret
     } 
 
-    .method private specialname rtspecialname static 
-            void  .cctor() cil managed
+    .method private specialname rtspecialname static void  .cctor() cil managed
     {
       
       .maxstack  10
-      IL_0000:  newobj     instance void assembly/matchResult@38::.ctor()
-      IL_0005:  stsfld     class assembly/matchResult@38 assembly/matchResult@38::@_instance
+      IL_0000:  newobj     instance void Verify13043/matchResult@38::.ctor()
+      IL_0005:  stsfld     class Verify13043/matchResult@38 Verify13043/matchResult@38::@_instance
       IL_000a:  ret
     } 
 
@@ -218,9 +211,8 @@
   .class auto ansi serializable sealed nested assembly beforefieldinit functionResult@43
          extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
   {
-    .field static assembly initonly class assembly/functionResult@43 @_instance
-    .method assembly specialname rtspecialname 
-            instance void  .ctor() cil managed
+    .field static assembly initonly class Verify13043/functionResult@43 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
     {
       .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
       .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
@@ -231,34 +223,31 @@
       IL_0006:  ret
     } 
 
-    .method public strict virtual instance bool 
-            Invoke(int32 n) cil managed
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
     {
       
       .maxstack  8
       IL_0000:  ldarg.1
-      IL_0001:  call       bool assembly::condition(int32)
+      IL_0001:  call       bool Verify13043::condition(int32)
       IL_0006:  ret
     } 
 
-    .method private specialname rtspecialname static 
-            void  .cctor() cil managed
+    .method private specialname rtspecialname static void  .cctor() cil managed
     {
       
       .maxstack  10
-      IL_0000:  newobj     instance void assembly/functionResult@43::.ctor()
-      IL_0005:  stsfld     class assembly/functionResult@43 assembly/functionResult@43::@_instance
+      IL_0000:  newobj     instance void Verify13043/functionResult@43::.ctor()
+      IL_0005:  stsfld     class Verify13043/functionResult@43 Verify13043/functionResult@43::@_instance
       IL_000a:  ret
     } 
 
   } 
 
-  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
-          get_list() cil managed
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_list() cil managed
   {
     
     .maxstack  8
-    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$assembly::list@3
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$Verify13043::list@3
     IL_0005:  ret
   } 
 
@@ -281,7 +270,7 @@
     .maxstack  4
     .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>> V_0)
     IL_0000:  ldarg.0
-    IL_0001:  newobj     instance void assembly/f@8::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>)
+    IL_0001:  newobj     instance void Verify13043/f@8::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>)
     IL_0006:  stloc.0
     IL_0007:  ldloc.0
     IL_0008:  ldarg.1
@@ -299,7 +288,7 @@
     .maxstack  4
     .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>> V_0)
     IL_0000:  ldarg.0
-    IL_0001:  newobj     instance void assembly/'f@27-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>)
+    IL_0001:  newobj     instance void Verify13043/'f@27-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>)
     IL_0006:  stloc.0
     IL_0007:  ldloc.0
     IL_0008:  ldarg.1
@@ -308,21 +297,19 @@
     IL_0010:  ret
   } 
 
-  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
-          get_matchResult() cil managed
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_matchResult() cil managed
   {
     
     .maxstack  8
-    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$assembly::matchResult@38
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$Verify13043::matchResult@38
     IL_0005:  ret
   } 
 
-  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
-          get_functionResult() cil managed
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_functionResult() cil managed
   {
     
     .maxstack  8
-    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$assembly::functionResult@43
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$Verify13043::functionResult@43
     IL_0005:  ret
   } 
 
@@ -330,23 +317,23 @@
           list()
   {
     .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
-    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_list()
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_list()
   } 
   .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
           matchResult()
   {
     .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
-    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_matchResult()
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_matchResult()
   } 
   .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
           functionResult()
   {
     .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
-    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_functionResult()
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_functionResult()
   } 
 } 
 
-.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Verify13043
        extends [runtime]System.Object
 {
   .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> list@3
@@ -378,32 +365,32 @@
     IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
                                                                                                                                                                     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
     IL_0017:  dup
-    IL_0018:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$assembly::list@3
+    IL_0018:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$Verify13043::list@3
     IL_001d:  stloc.0
-    IL_001e:  ldsfld     class assembly/matchResult@38 assembly/matchResult@38::@_instance
-    IL_0023:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_list()
-    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::dropWhileWithMatch(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>,
+    IL_001e:  ldsfld     class Verify13043/matchResult@38 Verify13043/matchResult@38::@_instance
+    IL_0023:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_list()
+    IL_0028:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::dropWhileWithMatch(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>,
                                                                                                                              class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
     IL_002d:  dup
-    IL_002e:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$assembly::matchResult@38
+    IL_002e:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$Verify13043::matchResult@38
     IL_0033:  stloc.1
     IL_0034:  ldstr      "Match: %A"
     IL_0039:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor(string)
     IL_003e:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
-    IL_0043:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_matchResult()
+    IL_0043:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_matchResult()
     IL_0048:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
     IL_004d:  pop
-    IL_004e:  ldsfld     class assembly/functionResult@43 assembly/functionResult@43::@_instance
-    IL_0053:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_list()
-    IL_0058:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::dropWhileWithFunction(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>,
+    IL_004e:  ldsfld     class Verify13043/functionResult@43 Verify13043/functionResult@43::@_instance
+    IL_0053:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_list()
+    IL_0058:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::dropWhileWithFunction(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>,
                                                                                                                                 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
     IL_005d:  dup
-    IL_005e:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$assembly::functionResult@43
+    IL_005e:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> '<StartupCode$assembly>'.$Verify13043::functionResult@43
     IL_0063:  stloc.2
     IL_0064:  ldstr      "Function: %A"
     IL_0069:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor(string)
     IL_006e:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
-    IL_0073:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> assembly::get_functionResult()
+    IL_0073:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_functionResult()
     IL_0078:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
     IL_007d:  pop
     IL_007e:  ret
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOn.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOn.fs
new file mode 100644
index 00000000000..3c7a8cceb80
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOn.fs
@@ -0,0 +1,44 @@
+module Verify13043
+
+let list = [1; 2; 3]
+let condition n = n < 3
+
+let dropWhileWithMatch condition list =
+  let rec f (l : List<int>) : List<int> =
+    match l with
+    | [] -> []
+    | head :: tail ->
+      match condition head with
+      | true -> f tail
+      | false -> head :: tail
+
+  f list
+
+(*
+  This function caused an Unhandled exception at execution time:
+
+  Unhandled exception. System.NullReferenceException: Object reference not set to an instance of an object.
+   at Program.f@14-1.Invoke(FSharpList`1 _arg1) in /workspaces/function-rec-fsharp-dotnet7-bug-demo/Program.fs:line 18
+   at Program.dropWhileWithFunction(FSharpFunc`2 condition, FSharpList`1 list) in /workspaces/function-rec-fsharp-dotnet7-bug-demo/Program.fs:line 21
+   at <StartupCode$function-rec-fsharp-dotnet7-bug-demo>.$Program.main@() in /workspaces/function-rec-fsharp-dotnet7-bug-demo/Program.fs:line 29
+*)
+let dropWhileWithFunction condition list =
+  let rec f : List<int> -> List<int> =
+    function
+    | [] -> []
+    | head :: tail ->
+      match condition head with
+      | true -> f tail
+      | false -> head :: tail
+
+  f list
+
+
+// this runs fine:
+let matchResult = dropWhileWithMatch condition list
+printfn "Match: %A" matchResult
+
+
+// and this results in a null reference exception
+let functionResult = dropWhileWithFunction condition list
+printfn "Function: %A" functionResult
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOn.fs.il.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOn.fs.il.debug.bsl
new file mode 100644
index 00000000000..0862fa8c6f5
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOn.fs.il.debug.bsl
@@ -0,0 +1,415 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Verify13043
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit f@8
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> Verify13043/f@8::condition
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> l) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+               int32 V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+      IL_0008:  brfalse.s  IL_000c
+
+      IL_000a:  br.s       IL_0012
+
+      IL_000c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+      IL_0011:  ret
+
+      IL_0012:  ldloc.0
+      IL_0013:  stloc.1
+      IL_0014:  ldloc.1
+      IL_0015:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+      IL_001a:  stloc.2
+      IL_001b:  ldloc.1
+      IL_001c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+      IL_0021:  stloc.3
+      IL_0022:  nop
+      IL_0023:  ldarg.0
+      IL_0024:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> Verify13043/f@8::condition
+      IL_0029:  ldloc.3
+      IL_002a:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::Invoke(!0)
+      IL_002f:  brfalse.s  IL_0036
+
+      IL_0031:  ldloc.2
+      IL_0032:  starg.s    l
+      IL_0034:  br.s       IL_0000
+
+      IL_0036:  ldloc.3
+      IL_0037:  ldloc.2
+      IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_003d:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'f@27-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> Verify13043/'f@27-1'::condition
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+               int32 V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+      IL_0008:  brfalse.s  IL_000c
+
+      IL_000a:  br.s       IL_0012
+
+      IL_000c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+      IL_0011:  ret
+
+      IL_0012:  ldloc.0
+      IL_0013:  stloc.1
+      IL_0014:  ldloc.1
+      IL_0015:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+      IL_001a:  stloc.2
+      IL_001b:  ldloc.1
+      IL_001c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+      IL_0021:  stloc.3
+      IL_0022:  nop
+      IL_0023:  ldarg.0
+      IL_0024:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> Verify13043/'f@27-1'::condition
+      IL_0029:  ldloc.3
+      IL_002a:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::Invoke(!0)
+      IL_002f:  brfalse.s  IL_0036
+
+      IL_0031:  ldloc.2
+      IL_0032:  starg.s    _arg1
+      IL_0034:  br.s       IL_0000
+
+      IL_0036:  ldloc.3
+      IL_0037:  ldloc.2
+      IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_003d:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit matchResult@38
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class Verify13043/matchResult@38 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  call       bool Verify13043::condition(int32)
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void Verify13043/matchResult@38::.ctor()
+      IL_0005:  stsfld     class Verify13043/matchResult@38 Verify13043/matchResult@38::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit functionResult@43
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class Verify13043/functionResult@43 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  call       bool Verify13043::condition(int32)
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void Verify13043/functionResult@43::.ctor()
+      IL_0005:  stsfld     class Verify13043/functionResult@43 Verify13043/functionResult@43::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> list@3
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> matchResult@38
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> functionResult@43
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_list() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::list@3
+    IL_0005:  ret
+  } 
+
+  .method public static bool  condition(int32 n) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldc.i4.3
+    IL_0002:  clt
+    IL_0004:  ret
+  } 
+
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
+          dropWhileWithMatch(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition,
+                             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> list) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>> V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  newobj     instance void Verify13043/f@8::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>)
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  ldarg.1
+    IL_0009:  tail.
+    IL_000b:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::Invoke(!0)
+    IL_0010:  ret
+  } 
+
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
+          dropWhileWithFunction(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition,
+                                class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> list) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>> V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  newobj     instance void Verify13043/'f@27-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>)
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  ldarg.1
+    IL_0009:  tail.
+    IL_000b:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::Invoke(!0)
+    IL_0010:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_matchResult() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::matchResult@38
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_functionResult() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::functionResult@43
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Verify13043::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Verify13043::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  6
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0008:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0017:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::list@3
+    IL_001c:  ldsfld     class Verify13043/matchResult@38 Verify13043/matchResult@38::@_instance
+    IL_0021:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_list()
+    IL_0026:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::dropWhileWithMatch(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>,
+                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    IL_002b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::matchResult@38
+    IL_0030:  ldstr      "Match: %A"
+    IL_0035:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor(string)
+    IL_003a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_003f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_matchResult()
+    IL_0044:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0049:  pop
+    IL_004a:  ldsfld     class Verify13043/functionResult@43 Verify13043/functionResult@43::@_instance
+    IL_004f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_list()
+    IL_0054:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::dropWhileWithFunction(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>,
+                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    IL_0059:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::functionResult@43
+    IL_005e:  ldstr      "Function: %A"
+    IL_0063:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor(string)
+    IL_0068:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_006d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_functionResult()
+    IL_0072:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0077:  pop
+    IL_0078:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          list()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_list()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          matchResult()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_matchResult()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          functionResult()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_functionResult()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Verify13043
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Verify13043::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOn.fs.il.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOn.fs.il.release.bsl
new file mode 100644
index 00000000000..0862fa8c6f5
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/TestFunctions/Verify13043_RealInternalSignatureOn.fs.il.release.bsl
@@ -0,0 +1,415 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Verify13043
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable sealed nested assembly beforefieldinit f@8
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> Verify13043/f@8::condition
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> l) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+               int32 V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+      IL_0008:  brfalse.s  IL_000c
+
+      IL_000a:  br.s       IL_0012
+
+      IL_000c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+      IL_0011:  ret
+
+      IL_0012:  ldloc.0
+      IL_0013:  stloc.1
+      IL_0014:  ldloc.1
+      IL_0015:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+      IL_001a:  stloc.2
+      IL_001b:  ldloc.1
+      IL_001c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+      IL_0021:  stloc.3
+      IL_0022:  nop
+      IL_0023:  ldarg.0
+      IL_0024:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> Verify13043/f@8::condition
+      IL_0029:  ldloc.3
+      IL_002a:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::Invoke(!0)
+      IL_002f:  brfalse.s  IL_0036
+
+      IL_0031:  ldloc.2
+      IL_0032:  starg.s    l
+      IL_0034:  br.s       IL_0000
+
+      IL_0036:  ldloc.3
+      IL_0037:  ldloc.2
+      IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_003d:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'f@27-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>
+  {
+    .field public class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition
+    .method assembly specialname rtspecialname instance void  .ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> Verify13043/'f@27-1'::condition
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Invoke(class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> _arg1) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_0,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_1,
+               class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> V_2,
+               int32 V_3)
+      IL_0000:  ldarg.1
+      IL_0001:  stloc.0
+      IL_0002:  ldloc.0
+      IL_0003:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+      IL_0008:  brfalse.s  IL_000c
+
+      IL_000a:  br.s       IL_0012
+
+      IL_000c:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+      IL_0011:  ret
+
+      IL_0012:  ldloc.0
+      IL_0013:  stloc.1
+      IL_0014:  ldloc.1
+      IL_0015:  call       instance class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_TailOrNull()
+      IL_001a:  stloc.2
+      IL_001b:  ldloc.1
+      IL_001c:  call       instance !0 class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_HeadOrDefault()
+      IL_0021:  stloc.3
+      IL_0022:  nop
+      IL_0023:  ldarg.0
+      IL_0024:  ldfld      class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> Verify13043/'f@27-1'::condition
+      IL_0029:  ldloc.3
+      IL_002a:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::Invoke(!0)
+      IL_002f:  brfalse.s  IL_0036
+
+      IL_0031:  ldloc.2
+      IL_0032:  starg.s    _arg1
+      IL_0034:  br.s       IL_0000
+
+      IL_0036:  ldloc.3
+      IL_0037:  ldloc.2
+      IL_0038:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                      class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+      IL_003d:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit matchResult@38
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class Verify13043/matchResult@38 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  call       bool Verify13043::condition(int32)
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void Verify13043/matchResult@38::.ctor()
+      IL_0005:  stsfld     class Verify13043/matchResult@38 Verify13043/matchResult@38::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit functionResult@43
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>
+  {
+    .field static assembly initonly class Verify13043/functionResult@43 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance bool Invoke(int32 n) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  call       bool Verify13043::condition(int32)
+      IL_0006:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void Verify13043/functionResult@43::.ctor()
+      IL_0005:  stsfld     class Verify13043/functionResult@43 Verify13043/functionResult@43::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> list@3
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> matchResult@38
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> functionResult@43
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_list() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::list@3
+    IL_0005:  ret
+  } 
+
+  .method public static bool  condition(int32 n) cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldc.i4.3
+    IL_0002:  clt
+    IL_0004:  ret
+  } 
+
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
+          dropWhileWithMatch(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition,
+                             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> list) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>> V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  newobj     instance void Verify13043/f@8::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>)
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  ldarg.1
+    IL_0009:  tail.
+    IL_000b:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::Invoke(!0)
+    IL_0010:  ret
+  } 
+
+  .method public static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> 
+          dropWhileWithFunction(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool> condition,
+                                class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> list) cil managed
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+    
+    .maxstack  4
+    .locals init (class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>> V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  newobj     instance void Verify13043/'f@27-1'::.ctor(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>)
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  ldarg.1
+    IL_0009:  tail.
+    IL_000b:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::Invoke(!0)
+    IL_0010:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_matchResult() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::matchResult@38
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> get_functionResult() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::functionResult@43
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Verify13043::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Verify13043::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  6
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::get_Empty()
+    IL_0008:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_000d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0012:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0> class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>::Cons(!0,
+                                                                                                                                                                    class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<!0>)
+    IL_0017:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::list@3
+    IL_001c:  ldsfld     class Verify13043/matchResult@38 Verify13043/matchResult@38::@_instance
+    IL_0021:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_list()
+    IL_0026:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::dropWhileWithMatch(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>,
+                                                                                                                             class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    IL_002b:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::matchResult@38
+    IL_0030:  ldstr      "Match: %A"
+    IL_0035:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor(string)
+    IL_003a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_003f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_matchResult()
+    IL_0044:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0049:  pop
+    IL_004a:  ldsfld     class Verify13043/functionResult@43 Verify13043/functionResult@43::@_instance
+    IL_004f:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_list()
+    IL_0054:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::dropWhileWithFunction(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,bool>,
+                                                                                                                                class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>)
+    IL_0059:  stsfld     class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::functionResult@43
+    IL_005e:  ldstr      "Function: %A"
+    IL_0063:  newobj     instance void class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`5<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>>::.ctor(string)
+    IL_0068:  call       !!0 [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::PrintFormatLine<class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>>(class [FSharp.Core]Microsoft.FSharp.Core.PrintfFormat`4<!!0,class [runtime]System.IO.TextWriter,class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Core.Unit>)
+    IL_006d:  call       class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_functionResult()
+    IL_0072:  callvirt   instance !1 class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>,class [FSharp.Core]Microsoft.FSharp.Core.Unit>::Invoke(!0)
+    IL_0077:  pop
+    IL_0078:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          list()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_list()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          matchResult()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_matchResult()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32>
+          functionResult()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Collections.FSharpList`1<int32> Verify13043::get_functionResult()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Verify13043
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Verify13043::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple02.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple02.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple02.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple02.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple02.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple02.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..e7bdf60e87e
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple02.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,93 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  newobj     instance void class [runtime]System.Tuple`2<int32,int32>::.ctor(!0,
+                                                                                          !1)
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple03.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple03.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple03.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple03.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple03.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple03.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..7bdcae4a84d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple03.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,95 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  newobj     instance void class [runtime]System.Tuple`3<int32,int32,int32>::.ctor(!0,
+                                                                                                !1,
+                                                                                                !2)
+    IL_0008:  pop
+    IL_0009:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple04.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple04.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple04.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple04.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple04.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple04.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..671936095f5
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple04.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,97 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  ldc.i4.4
+    IL_0004:  newobj     instance void class [runtime]System.Tuple`4<int32,int32,int32,int32>::.ctor(!0,
+                                                                                                      !1,
+                                                                                                      !2,
+                                                                                                      !3)
+    IL_0009:  pop
+    IL_000a:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple05.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple05.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple05.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple05.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple05.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple05.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..5a0849a78f9
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple05.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,99 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  ldc.i4.4
+    IL_0004:  ldc.i4.5
+    IL_0005:  newobj     instance void class [runtime]System.Tuple`5<int32,int32,int32,int32,int32>::.ctor(!0,
+                                                                                                            !1,
+                                                                                                            !2,
+                                                                                                            !3,
+                                                                                                            !4)
+    IL_000a:  pop
+    IL_000b:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple06.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple06.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple06.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple06.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple06.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple06.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..e38d6e0191d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple06.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,101 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly static void  staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  ldc.i4.4
+    IL_0004:  ldc.i4.5
+    IL_0005:  ldc.i4.6
+    IL_0006:  newobj     instance void class [runtime]System.Tuple`6<int32,int32,int32,int32,int32,int32>::.ctor(!0,
+                                                                                                                  !1,
+                                                                                                                  !2,
+                                                                                                                  !3,
+                                                                                                                  !4,
+                                                                                                                  !5)
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple07.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple07.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple07.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple07.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple07.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple07.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..52c6b120eee
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple07.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,103 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  9
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  ldc.i4.4
+    IL_0004:  ldc.i4.5
+    IL_0005:  ldc.i4.6
+    IL_0006:  ldc.i4.7
+    IL_0007:  newobj     instance void class [runtime]System.Tuple`7<int32,int32,int32,int32,int32,int32,int32>::.ctor(!0,
+                                                                                                                        !1,
+                                                                                                                        !2,
+                                                                                                                        !3,
+                                                                                                                        !4,
+                                                                                                                        !5,
+                                                                                                                        !6)
+    IL_000c:  pop
+    IL_000d:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple08.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple08.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple08.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple08.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple08.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple08.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..b49b131d3d7
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuple08.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,106 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  10
+    IL_0000:  ldc.i4.1
+    IL_0001:  ldc.i4.2
+    IL_0002:  ldc.i4.3
+    IL_0003:  ldc.i4.4
+    IL_0004:  ldc.i4.5
+    IL_0005:  ldc.i4.6
+    IL_0006:  ldc.i4.7
+    IL_0007:  ldc.i4.8
+    IL_0008:  newobj     instance void class [runtime]System.Tuple`1<int32>::.ctor(!0)
+    IL_000d:  newobj     instance void class [runtime]System.Tuple`8<int32,int32,int32,int32,int32,int32,int32,class [runtime]System.Tuple`1<int32>>::.ctor(!0,
+                                                                                                                                                              !1,
+                                                                                                                                                              !2,
+                                                                                                                                                              !3,
+                                                                                                                                                              !4,
+                                                                                                                                                              !5,
+                                                                                                                                                              !6,
+                                                                                                                                                              !7)
+    IL_0012:  pop
+    IL_0013:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/TupleMonster.fs.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/TupleMonster.fs.RealInternalSignatureOff.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/TupleMonster.fs.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/TupleMonster.fs.RealInternalSignatureOff.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/TupleMonster.fs.RealInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/TupleMonster.fs.RealInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..6bea3250fef
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/TupleMonster.fs.RealInternalSignatureOn.il.bsl
@@ -0,0 +1,144 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  28
+    IL_0000:  ldc.i4.s   97
+    IL_0002:  ldc.i4.s   98
+    IL_0004:  ldc.i4.s   99
+    IL_0006:  ldc.i4.s   100
+    IL_0008:  ldc.i4.s   101
+    IL_000a:  ldc.i4.s   102
+    IL_000c:  ldc.i4.s   103
+    IL_000e:  ldc.i4.s   104
+    IL_0010:  ldc.i4.s   105
+    IL_0012:  ldc.i4.s   106
+    IL_0014:  ldc.i4.s   107
+    IL_0016:  ldc.i4.s   108
+    IL_0018:  ldc.i4.s   109
+    IL_001a:  ldc.i4.s   110
+    IL_001c:  ldc.i4.s   111
+    IL_001e:  ldc.i4.s   112
+    IL_0020:  ldc.i4.s   113
+    IL_0022:  ldc.i4.s   114
+    IL_0024:  ldc.i4.s   115
+    IL_0026:  ldc.i4.s   116
+    IL_0028:  ldc.i4.s   117
+    IL_002a:  ldc.i4.s   118
+    IL_002c:  ldc.i4.s   119
+    IL_002e:  ldc.i4.s   120
+    IL_0030:  ldc.i4.s   121
+    IL_0032:  ldc.i4.s   122
+    IL_0034:  newobj     instance void class [runtime]System.Tuple`5<char,char,char,char,char>::.ctor(!0,
+                                                                                                       !1,
+                                                                                                       !2,
+                                                                                                       !3,
+                                                                                                       !4)
+    IL_0039:  newobj     instance void class [runtime]System.Tuple`8<char,char,char,char,char,char,char,class [runtime]System.Tuple`5<char,char,char,char,char>>::.ctor(!0,
+                                                                                                                                                                          !1,
+                                                                                                                                                                          !2,
+                                                                                                                                                                          !3,
+                                                                                                                                                                          !4,
+                                                                                                                                                                          !5,
+                                                                                                                                                                          !6,
+                                                                                                                                                                          !7)
+    IL_003e:  newobj     instance void class [runtime]System.Tuple`8<char,char,char,char,char,char,char,class [runtime]System.Tuple`8<char,char,char,char,char,char,char,class [runtime]System.Tuple`5<char,char,char,char,char>>>::.ctor(!0,
+                                                                                                                                                                                                                                             !1,
+                                                                                                                                                                                                                                             !2,
+                                                                                                                                                                                                                                             !3,
+                                                                                                                                                                                                                                             !4,
+                                                                                                                                                                                                                                             !5,
+                                                                                                                                                                                                                                             !6,
+                                                                                                                                                                                                                                             !7)
+    IL_0043:  newobj     instance void class [runtime]System.Tuple`8<char,char,char,char,char,char,char,class [runtime]System.Tuple`8<char,char,char,char,char,char,char,class [runtime]System.Tuple`8<char,char,char,char,char,char,char,class [runtime]System.Tuple`5<char,char,char,char,char>>>>::.ctor(!0,
+                                                                                                                                                                                                                                                                                                                !1,
+                                                                                                                                                                                                                                                                                                                !2,
+                                                                                                                                                                                                                                                                                                                !3,
+                                                                                                                                                                                                                                                                                                                !4,
+                                                                                                                                                                                                                                                                                                                !5,
+                                                                                                                                                                                                                                                                                                                !6,
+                                                                                                                                                                                                                                                                                                                !7)
+    IL_0048:  pop
+    IL_0049:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuples.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuples.fs
index b03ccebada0..e72af2b7caf 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuples.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/Tuples.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open Xunit
 open System.IO
@@ -24,45 +24,94 @@ module Tuples =
         |> verifyCompilation
 
     // SOURCE=Tuple02.fs      SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Tuple02.exe"		# Tuple02.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Tuple02.fs"|])>]
-    let ``Tuple02_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Tuple02.fs"|])>]
+    let ``Tuple02_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    // SOURCE=Tuple02.fs      SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Tuple02.exe"		# Tuple02.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Tuple02.fs"|])>]
+    let ``Tuple02_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=Tuple03.fs      SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Tuple03.exe"		# Tuple03.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Tuple03.fs"|])>]
+    let ``Tuple03_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=Tuple03.fs      SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Tuple03.exe"		# Tuple03.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Tuple03.fs"|])>]
-    let ``Tuple03_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Tuple03.fs"|])>]
+    let ``Tuple03_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     // SOURCE=Tuple04.fs      SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Tuple04.exe"		# Tuple04.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Tuple04.fs"|])>]
-    let ``Tuple04_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Tuple04.fs"|])>]
+    let ``Tuple04_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    // SOURCE=Tuple04.fs      SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Tuple04.exe"		# Tuple04.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Tuple04.fs"|])>]
+    let ``Tuple04_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=Tuple05.fs      SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Tuple05.exe"		# Tuple05.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Tuple05.fs"|])>]
+    let ``Tuple05_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=Tuple05.fs      SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Tuple05.exe"		# Tuple05.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Tuple05.fs"|])>]
-    let ``Tuple05_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Tuple05.fs"|])>]
+    let ``Tuple05_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     // SOURCE=Tuple06.fs      SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Tuple06.exe"		# Tuple06.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Tuple06.fs"|])>]
-    let ``Tuple06_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Tuple06.fs"|])>]
+    let ``Tuple06_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     // SOURCE=Tuple07.fs      SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Tuple07.exe"		# Tuple07.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Tuple07.fs"|])>]
-    let ``Tuple07_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Tuple07.fs"|])>]
+    let ``Tuple07_RealInternalSignatureOn_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    // SOURCE=Tuple07.fs      SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Tuple07.exe"		# Tuple07.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Tuple07.fs"|])>]
+    let ``Tuple07_RealInternalSignatureOff_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=Tuple08.fs      SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Tuple08.exe"		# Tuple08.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"Tuple08.fs"|])>]
+    let ``Tuple08_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=Tuple08.fs      SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd Tuple08.exe"		# Tuple08.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"Tuple08.fs"|])>]
-    let ``Tuple08_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"Tuple08.fs"|])>]
+    let ``Tuple08_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
 
     // SOURCE=OptionalArg01.fs      SCFLAGS="-g --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd OptionalArg01.exe"		# OptionalArg01.fs - test optimizatons
@@ -72,9 +121,17 @@ module Tuples =
         |> verifyCompilation
 
     // SOURCE=TupleMonster.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TupleMonster.exe"		# TupleMonster.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"TupleMonster.fs"|])>]
-    let ``TupleMonster_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"TupleMonster.fs"|])>]
+    let ``TupleMonster_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
+        |> verifyCompilation
+
+    // SOURCE=TupleMonster.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize-" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TupleMonster.exe"		# TupleMonster.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"TupleMonster.fs"|])>]
+    let ``TupleMonster_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
         |> verifyCompilation
 
     // SOURCE=TupleElimination.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd TupleElimination.exe"		# TupleElimination.fs -
@@ -84,7 +141,15 @@ module Tuples =
         |> verifyCompilation
 
     // SOURCE=ValueTupleAliasConstructor.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ValueTupleAliasConstructor.exe"		# ValueTupleAliasConstructor.fs -
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"ValueTupleAliasConstructor.fs"|])>]
-    let ``ValueTupleAliasConstructor_fs`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOn", Includes=[|"ValueTupleAliasConstructor.fs"|])>]
+    let ``ValueTupleAliasConstructor_RealInternalSignatureOn_fs`` compilation =
+        compilation
+        |> withRealInternalSignatureOn
+        |> verifyCompilation
+
+    // SOURCE=ValueTupleAliasConstructor.fs SCFLAGS="-g --test:EmitFeeFeeAs100001 --optimize+" COMPILE_ONLY=1 POSTCMD="..\\CompareIL.cmd ValueTupleAliasConstructor.exe"		# ValueTupleAliasConstructor.fs -
+    [<Theory; Directory(__SOURCE_DIRECTORY__, BaselineSuffix=".RealInternalSignatureOff", Includes=[|"ValueTupleAliasConstructor.fs"|])>]
+    let ``ValueTupleAliasConstructor_RealInternalSignatureOff_fs`` compilation =
         compilation
+        |> withRealInternalSignatureOff
         |> verifyCompilation
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/ValueTupleAliasConstructor.fs.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/ValueTupleAliasConstructor.fs.RealInternalSignatureOff.il.net472.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/ValueTupleAliasConstructor.fs.il.net472.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/ValueTupleAliasConstructor.fs.RealInternalSignatureOff.il.net472.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/ValueTupleAliasConstructor.fs.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/ValueTupleAliasConstructor.fs.RealInternalSignatureOff.il.netcore.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/ValueTupleAliasConstructor.fs.il.netcore.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/ValueTupleAliasConstructor.fs.RealInternalSignatureOff.il.netcore.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/ValueTupleAliasConstructor.fs.RealInternalSignatureOn.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/ValueTupleAliasConstructor.fs.RealInternalSignatureOn.il.net472.bsl
new file mode 100644
index 00000000000..45dfb455378
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/ValueTupleAliasConstructor.fs.RealInternalSignatureOn.il.net472.bsl
@@ -0,0 +1,93 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.2
+    IL_0001:  ldc.i4.2
+    IL_0002:  newobj     instance void valuetype [runtime]System.ValueTuple`2<int32,int32>::.ctor(!0,
+                                                                                                   !1)
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/ValueTupleAliasConstructor.fs.RealInternalSignatureOn.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/ValueTupleAliasConstructor.fs.RealInternalSignatureOn.il.netcore.bsl
new file mode 100644
index 00000000000..e9fe8f2e458
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/Tuples/ValueTupleAliasConstructor.fs.RealInternalSignatureOn.il.netcore.bsl
@@ -0,0 +1,93 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+
+  
+  
+
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.2
+    IL_0001:  ldc.i4.2
+    IL_0002:  newobj     instance void valuetype [runtime]System.ValueTuple`2<int32,int32>::.ctor(!0,
+                                                                                                         !1)
+    IL_0007:  pop
+    IL_0008:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/Operators.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/Operators.fs
index edf76bdf4c8..a6b967742fe 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/Operators.fs
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/Operators.fs
@@ -1,4 +1,4 @@
-namespace EmittedIL
+namespace EmittedIL.RealInternalSignature
 
 open Xunit
 open FSharp.Test
@@ -6,9 +6,19 @@ open FSharp.Test.Compiler
 
 module Operators =
 
-    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"decimal_comparison.fs"|])>]
-    let ``Validate that non generic (fast) code is emitted  for comparison involving decimals`` compilation =
+    // ``Validate that non generic (fast) code is emitted  for comparison involving decimals RealInternalSignatureOff`` compilation =
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"decimal_comparison_RealInternalSignatureOff.fs"|])>]
+    let ``Non generic (fast) code emitted for decimal comparison RealInternalSignatureOff`` compilation =
         compilation
         |> asExe
+        |> withRealInternalSignatureOff
         |> ignoreWarnings
-        |> verifyILBaseline
\ No newline at end of file
+        |> verifyILBaseline
+
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"decimal_comparison_RealInternalSignatureOn.fs"|])>]
+    let ``Non generic (fast) code emitted for decimal comparison RealInternalSignatureOn`` compilation =
+        compilation
+        |> asExe
+        |> withRealInternalSignatureOn
+        |> ignoreWarnings
+        |> verifyILBaseline
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOff.fs
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison.fs
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOff.fs
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOff.fs.il.net472.debug.bsl
similarity index 98%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison.fs.il.net472.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOff.fs.il.net472.debug.bsl
index 761a485a8d8..e99df0be6b9 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison.fs.il.net472.release.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOff.fs.il.net472.debug.bsl
@@ -40,13 +40,13 @@
 
 
 
-.class public abstract auto ansi sealed Decimal_comparison
+.class public abstract auto ansi sealed Decimal_comparison_RealInternalSignatureOff
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
 } 
 
-.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Decimal_comparison
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Decimal_comparison_RealInternalSignatureOff
        extends [runtime]System.Object
 {
   .field static assembly int32 init@
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOff.fs.il.net472.release.bsl
similarity index 98%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison.fs.il.net472.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOff.fs.il.net472.release.bsl
index 761a485a8d8..e99df0be6b9 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison.fs.il.net472.debug.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOff.fs.il.net472.release.bsl
@@ -40,13 +40,13 @@
 
 
 
-.class public abstract auto ansi sealed Decimal_comparison
+.class public abstract auto ansi sealed Decimal_comparison_RealInternalSignatureOff
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
 } 
 
-.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Decimal_comparison
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Decimal_comparison_RealInternalSignatureOff
        extends [runtime]System.Object
 {
   .field static assembly int32 init@
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOff.fs.il.netcore.debug.bsl
similarity index 98%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison.fs.il.netcore.release.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOff.fs.il.netcore.debug.bsl
index ae2bfc33410..4a3db2bbbcb 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison.fs.il.netcore.release.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOff.fs.il.netcore.debug.bsl
@@ -40,13 +40,13 @@
 
 
 
-.class public abstract auto ansi sealed Decimal_comparison
+.class public abstract auto ansi sealed Decimal_comparison_RealInternalSignatureOff
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
 } 
 
-.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Decimal_comparison
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Decimal_comparison_RealInternalSignatureOff
        extends [runtime]System.Object
 {
   .field static assembly int32 init@
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOff.fs.il.netcore.release.bsl
similarity index 98%
rename from tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison.fs.il.netcore.debug.bsl
rename to tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOff.fs.il.netcore.release.bsl
index ae2bfc33410..4a3db2bbbcb 100644
--- a/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison.fs.il.netcore.debug.bsl
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOff.fs.il.netcore.release.bsl
@@ -40,13 +40,13 @@
 
 
 
-.class public abstract auto ansi sealed Decimal_comparison
+.class public abstract auto ansi sealed Decimal_comparison_RealInternalSignatureOff
        extends [runtime]System.Object
 {
   .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
 } 
 
-.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Decimal_comparison
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Decimal_comparison_RealInternalSignatureOff
        extends [runtime]System.Object
 {
   .field static assembly int32 init@
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOn.fs b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOn.fs
new file mode 100644
index 00000000000..1097b688029
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOn.fs
@@ -0,0 +1,11 @@
+// #NoMono #NoMT #CodeGen #EmittedIL 
+// Validate we emit non-generic (=fast) code for comparison involving decimals
+// See DevDiv:217807 (1.0M < 2.0M should be fast, not go through generic comparison code path)
+let _ = 1.0M < 2.0M
+let _ = 1.0M <= 2.0M
+let _ = 1.0M > 2.0M
+let _ = 1.0M >= 2.0M
+let _ = 1.0M = 2.0M
+let _ = 1.0M <> 2.0M
+let _ = 1.0M = 2.0M
+let _ = compare 1.0M 2.0M
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOn.fs.il.net472.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOn.fs.il.net472.debug.bsl
new file mode 100644
index 00000000000..e845b923b38
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOn.fs.il.net472.debug.bsl
@@ -0,0 +1,275 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Decimal_comparison_RealInternalSignatureOn
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Decimal_comparison_RealInternalSignatureOn::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Decimal_comparison_RealInternalSignatureOn::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.s   10
+    IL_0002:  ldc.i4.0
+    IL_0003:  ldc.i4.0
+    IL_0004:  ldc.i4.0
+    IL_0005:  ldc.i4.1
+    IL_0006:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_000b:  ldc.i4.s   20
+    IL_000d:  ldc.i4.0
+    IL_000e:  ldc.i4.0
+    IL_000f:  ldc.i4.0
+    IL_0010:  ldc.i4.1
+    IL_0011:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0016:  call       bool [netstandard]System.Decimal::op_LessThan(valuetype [netstandard]System.Decimal,
+                                                                       valuetype [netstandard]System.Decimal)
+    IL_001b:  pop
+    IL_001c:  ldc.i4.s   10
+    IL_001e:  ldc.i4.0
+    IL_001f:  ldc.i4.0
+    IL_0020:  ldc.i4.0
+    IL_0021:  ldc.i4.1
+    IL_0022:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0027:  ldc.i4.s   20
+    IL_0029:  ldc.i4.0
+    IL_002a:  ldc.i4.0
+    IL_002b:  ldc.i4.0
+    IL_002c:  ldc.i4.1
+    IL_002d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0032:  call       bool [netstandard]System.Decimal::op_LessThanOrEqual(valuetype [netstandard]System.Decimal,
+                                                                              valuetype [netstandard]System.Decimal)
+    IL_0037:  pop
+    IL_0038:  ldc.i4.s   10
+    IL_003a:  ldc.i4.0
+    IL_003b:  ldc.i4.0
+    IL_003c:  ldc.i4.0
+    IL_003d:  ldc.i4.1
+    IL_003e:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0043:  ldc.i4.s   20
+    IL_0045:  ldc.i4.0
+    IL_0046:  ldc.i4.0
+    IL_0047:  ldc.i4.0
+    IL_0048:  ldc.i4.1
+    IL_0049:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_004e:  call       bool [netstandard]System.Decimal::op_GreaterThan(valuetype [netstandard]System.Decimal,
+                                                                          valuetype [netstandard]System.Decimal)
+    IL_0053:  pop
+    IL_0054:  ldc.i4.s   10
+    IL_0056:  ldc.i4.0
+    IL_0057:  ldc.i4.0
+    IL_0058:  ldc.i4.0
+    IL_0059:  ldc.i4.1
+    IL_005a:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_005f:  ldc.i4.s   20
+    IL_0061:  ldc.i4.0
+    IL_0062:  ldc.i4.0
+    IL_0063:  ldc.i4.0
+    IL_0064:  ldc.i4.1
+    IL_0065:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_006a:  call       bool [netstandard]System.Decimal::op_GreaterThanOrEqual(valuetype [netstandard]System.Decimal,
+                                                                                 valuetype [netstandard]System.Decimal)
+    IL_006f:  pop
+    IL_0070:  ldc.i4.s   10
+    IL_0072:  ldc.i4.0
+    IL_0073:  ldc.i4.0
+    IL_0074:  ldc.i4.0
+    IL_0075:  ldc.i4.1
+    IL_0076:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_007b:  ldc.i4.s   20
+    IL_007d:  ldc.i4.0
+    IL_007e:  ldc.i4.0
+    IL_007f:  ldc.i4.0
+    IL_0080:  ldc.i4.1
+    IL_0081:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0086:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                       valuetype [netstandard]System.Decimal)
+    IL_008b:  pop
+    IL_008c:  ldc.i4.s   10
+    IL_008e:  ldc.i4.0
+    IL_008f:  ldc.i4.0
+    IL_0090:  ldc.i4.0
+    IL_0091:  ldc.i4.1
+    IL_0092:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0097:  ldc.i4.s   20
+    IL_0099:  ldc.i4.0
+    IL_009a:  ldc.i4.0
+    IL_009b:  ldc.i4.0
+    IL_009c:  ldc.i4.1
+    IL_009d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00a2:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                       valuetype [netstandard]System.Decimal)
+    IL_00a7:  ldc.i4.0
+    IL_00a8:  ceq
+    IL_00aa:  pop
+    IL_00ab:  ldc.i4.s   10
+    IL_00ad:  ldc.i4.0
+    IL_00ae:  ldc.i4.0
+    IL_00af:  ldc.i4.0
+    IL_00b0:  ldc.i4.1
+    IL_00b1:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00b6:  ldc.i4.s   20
+    IL_00b8:  ldc.i4.0
+    IL_00b9:  ldc.i4.0
+    IL_00ba:  ldc.i4.0
+    IL_00bb:  ldc.i4.1
+    IL_00bc:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00c1:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                       valuetype [netstandard]System.Decimal)
+    IL_00c6:  pop
+    IL_00c7:  ldc.i4.s   10
+    IL_00c9:  ldc.i4.0
+    IL_00ca:  ldc.i4.0
+    IL_00cb:  ldc.i4.0
+    IL_00cc:  ldc.i4.1
+    IL_00cd:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00d2:  ldc.i4.s   20
+    IL_00d4:  ldc.i4.0
+    IL_00d5:  ldc.i4.0
+    IL_00d6:  ldc.i4.0
+    IL_00d7:  ldc.i4.1
+    IL_00d8:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00dd:  call       int32 [netstandard]System.Decimal::Compare(valuetype [netstandard]System.Decimal,
+                                                                    valuetype [netstandard]System.Decimal)
+    IL_00e2:  pop
+    IL_00e3:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Decimal_comparison_RealInternalSignatureOn
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Decimal_comparison_RealInternalSignatureOn::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOn.fs.il.net472.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOn.fs.il.net472.release.bsl
new file mode 100644
index 00000000000..e845b923b38
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOn.fs.il.net472.release.bsl
@@ -0,0 +1,275 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Decimal_comparison_RealInternalSignatureOn
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Decimal_comparison_RealInternalSignatureOn::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Decimal_comparison_RealInternalSignatureOn::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.s   10
+    IL_0002:  ldc.i4.0
+    IL_0003:  ldc.i4.0
+    IL_0004:  ldc.i4.0
+    IL_0005:  ldc.i4.1
+    IL_0006:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_000b:  ldc.i4.s   20
+    IL_000d:  ldc.i4.0
+    IL_000e:  ldc.i4.0
+    IL_000f:  ldc.i4.0
+    IL_0010:  ldc.i4.1
+    IL_0011:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0016:  call       bool [netstandard]System.Decimal::op_LessThan(valuetype [netstandard]System.Decimal,
+                                                                       valuetype [netstandard]System.Decimal)
+    IL_001b:  pop
+    IL_001c:  ldc.i4.s   10
+    IL_001e:  ldc.i4.0
+    IL_001f:  ldc.i4.0
+    IL_0020:  ldc.i4.0
+    IL_0021:  ldc.i4.1
+    IL_0022:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0027:  ldc.i4.s   20
+    IL_0029:  ldc.i4.0
+    IL_002a:  ldc.i4.0
+    IL_002b:  ldc.i4.0
+    IL_002c:  ldc.i4.1
+    IL_002d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0032:  call       bool [netstandard]System.Decimal::op_LessThanOrEqual(valuetype [netstandard]System.Decimal,
+                                                                              valuetype [netstandard]System.Decimal)
+    IL_0037:  pop
+    IL_0038:  ldc.i4.s   10
+    IL_003a:  ldc.i4.0
+    IL_003b:  ldc.i4.0
+    IL_003c:  ldc.i4.0
+    IL_003d:  ldc.i4.1
+    IL_003e:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0043:  ldc.i4.s   20
+    IL_0045:  ldc.i4.0
+    IL_0046:  ldc.i4.0
+    IL_0047:  ldc.i4.0
+    IL_0048:  ldc.i4.1
+    IL_0049:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_004e:  call       bool [netstandard]System.Decimal::op_GreaterThan(valuetype [netstandard]System.Decimal,
+                                                                          valuetype [netstandard]System.Decimal)
+    IL_0053:  pop
+    IL_0054:  ldc.i4.s   10
+    IL_0056:  ldc.i4.0
+    IL_0057:  ldc.i4.0
+    IL_0058:  ldc.i4.0
+    IL_0059:  ldc.i4.1
+    IL_005a:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_005f:  ldc.i4.s   20
+    IL_0061:  ldc.i4.0
+    IL_0062:  ldc.i4.0
+    IL_0063:  ldc.i4.0
+    IL_0064:  ldc.i4.1
+    IL_0065:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_006a:  call       bool [netstandard]System.Decimal::op_GreaterThanOrEqual(valuetype [netstandard]System.Decimal,
+                                                                                 valuetype [netstandard]System.Decimal)
+    IL_006f:  pop
+    IL_0070:  ldc.i4.s   10
+    IL_0072:  ldc.i4.0
+    IL_0073:  ldc.i4.0
+    IL_0074:  ldc.i4.0
+    IL_0075:  ldc.i4.1
+    IL_0076:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_007b:  ldc.i4.s   20
+    IL_007d:  ldc.i4.0
+    IL_007e:  ldc.i4.0
+    IL_007f:  ldc.i4.0
+    IL_0080:  ldc.i4.1
+    IL_0081:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0086:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                       valuetype [netstandard]System.Decimal)
+    IL_008b:  pop
+    IL_008c:  ldc.i4.s   10
+    IL_008e:  ldc.i4.0
+    IL_008f:  ldc.i4.0
+    IL_0090:  ldc.i4.0
+    IL_0091:  ldc.i4.1
+    IL_0092:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0097:  ldc.i4.s   20
+    IL_0099:  ldc.i4.0
+    IL_009a:  ldc.i4.0
+    IL_009b:  ldc.i4.0
+    IL_009c:  ldc.i4.1
+    IL_009d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00a2:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                       valuetype [netstandard]System.Decimal)
+    IL_00a7:  ldc.i4.0
+    IL_00a8:  ceq
+    IL_00aa:  pop
+    IL_00ab:  ldc.i4.s   10
+    IL_00ad:  ldc.i4.0
+    IL_00ae:  ldc.i4.0
+    IL_00af:  ldc.i4.0
+    IL_00b0:  ldc.i4.1
+    IL_00b1:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00b6:  ldc.i4.s   20
+    IL_00b8:  ldc.i4.0
+    IL_00b9:  ldc.i4.0
+    IL_00ba:  ldc.i4.0
+    IL_00bb:  ldc.i4.1
+    IL_00bc:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00c1:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                       valuetype [netstandard]System.Decimal)
+    IL_00c6:  pop
+    IL_00c7:  ldc.i4.s   10
+    IL_00c9:  ldc.i4.0
+    IL_00ca:  ldc.i4.0
+    IL_00cb:  ldc.i4.0
+    IL_00cc:  ldc.i4.1
+    IL_00cd:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00d2:  ldc.i4.s   20
+    IL_00d4:  ldc.i4.0
+    IL_00d5:  ldc.i4.0
+    IL_00d6:  ldc.i4.0
+    IL_00d7:  ldc.i4.1
+    IL_00d8:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00dd:  call       int32 [netstandard]System.Decimal::Compare(valuetype [netstandard]System.Decimal,
+                                                                    valuetype [netstandard]System.Decimal)
+    IL_00e2:  pop
+    IL_00e3:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Decimal_comparison_RealInternalSignatureOn
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Decimal_comparison_RealInternalSignatureOn::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOn.fs.il.netcore.debug.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOn.fs.il.netcore.debug.bsl
new file mode 100644
index 00000000000..71cfc585372
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOn.fs.il.netcore.debug.bsl
@@ -0,0 +1,275 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Decimal_comparison_RealInternalSignatureOn
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Decimal_comparison_RealInternalSignatureOn::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Decimal_comparison_RealInternalSignatureOn::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.s   10
+    IL_0002:  ldc.i4.0
+    IL_0003:  ldc.i4.0
+    IL_0004:  ldc.i4.0
+    IL_0005:  ldc.i4.1
+    IL_0006:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_000b:  ldc.i4.s   20
+    IL_000d:  ldc.i4.0
+    IL_000e:  ldc.i4.0
+    IL_000f:  ldc.i4.0
+    IL_0010:  ldc.i4.1
+    IL_0011:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0016:  call       bool [netstandard]System.Decimal::op_LessThan(valuetype [netstandard]System.Decimal,
+                                                                       valuetype [netstandard]System.Decimal)
+    IL_001b:  pop
+    IL_001c:  ldc.i4.s   10
+    IL_001e:  ldc.i4.0
+    IL_001f:  ldc.i4.0
+    IL_0020:  ldc.i4.0
+    IL_0021:  ldc.i4.1
+    IL_0022:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0027:  ldc.i4.s   20
+    IL_0029:  ldc.i4.0
+    IL_002a:  ldc.i4.0
+    IL_002b:  ldc.i4.0
+    IL_002c:  ldc.i4.1
+    IL_002d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0032:  call       bool [netstandard]System.Decimal::op_LessThanOrEqual(valuetype [netstandard]System.Decimal,
+                                                                              valuetype [netstandard]System.Decimal)
+    IL_0037:  pop
+    IL_0038:  ldc.i4.s   10
+    IL_003a:  ldc.i4.0
+    IL_003b:  ldc.i4.0
+    IL_003c:  ldc.i4.0
+    IL_003d:  ldc.i4.1
+    IL_003e:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0043:  ldc.i4.s   20
+    IL_0045:  ldc.i4.0
+    IL_0046:  ldc.i4.0
+    IL_0047:  ldc.i4.0
+    IL_0048:  ldc.i4.1
+    IL_0049:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_004e:  call       bool [netstandard]System.Decimal::op_GreaterThan(valuetype [netstandard]System.Decimal,
+                                                                          valuetype [netstandard]System.Decimal)
+    IL_0053:  pop
+    IL_0054:  ldc.i4.s   10
+    IL_0056:  ldc.i4.0
+    IL_0057:  ldc.i4.0
+    IL_0058:  ldc.i4.0
+    IL_0059:  ldc.i4.1
+    IL_005a:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_005f:  ldc.i4.s   20
+    IL_0061:  ldc.i4.0
+    IL_0062:  ldc.i4.0
+    IL_0063:  ldc.i4.0
+    IL_0064:  ldc.i4.1
+    IL_0065:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_006a:  call       bool [netstandard]System.Decimal::op_GreaterThanOrEqual(valuetype [netstandard]System.Decimal,
+                                                                                 valuetype [netstandard]System.Decimal)
+    IL_006f:  pop
+    IL_0070:  ldc.i4.s   10
+    IL_0072:  ldc.i4.0
+    IL_0073:  ldc.i4.0
+    IL_0074:  ldc.i4.0
+    IL_0075:  ldc.i4.1
+    IL_0076:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_007b:  ldc.i4.s   20
+    IL_007d:  ldc.i4.0
+    IL_007e:  ldc.i4.0
+    IL_007f:  ldc.i4.0
+    IL_0080:  ldc.i4.1
+    IL_0081:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0086:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                       valuetype [netstandard]System.Decimal)
+    IL_008b:  pop
+    IL_008c:  ldc.i4.s   10
+    IL_008e:  ldc.i4.0
+    IL_008f:  ldc.i4.0
+    IL_0090:  ldc.i4.0
+    IL_0091:  ldc.i4.1
+    IL_0092:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0097:  ldc.i4.s   20
+    IL_0099:  ldc.i4.0
+    IL_009a:  ldc.i4.0
+    IL_009b:  ldc.i4.0
+    IL_009c:  ldc.i4.1
+    IL_009d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00a2:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                       valuetype [netstandard]System.Decimal)
+    IL_00a7:  ldc.i4.0
+    IL_00a8:  ceq
+    IL_00aa:  pop
+    IL_00ab:  ldc.i4.s   10
+    IL_00ad:  ldc.i4.0
+    IL_00ae:  ldc.i4.0
+    IL_00af:  ldc.i4.0
+    IL_00b0:  ldc.i4.1
+    IL_00b1:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00b6:  ldc.i4.s   20
+    IL_00b8:  ldc.i4.0
+    IL_00b9:  ldc.i4.0
+    IL_00ba:  ldc.i4.0
+    IL_00bb:  ldc.i4.1
+    IL_00bc:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00c1:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                       valuetype [netstandard]System.Decimal)
+    IL_00c6:  pop
+    IL_00c7:  ldc.i4.s   10
+    IL_00c9:  ldc.i4.0
+    IL_00ca:  ldc.i4.0
+    IL_00cb:  ldc.i4.0
+    IL_00cc:  ldc.i4.1
+    IL_00cd:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00d2:  ldc.i4.s   20
+    IL_00d4:  ldc.i4.0
+    IL_00d5:  ldc.i4.0
+    IL_00d6:  ldc.i4.0
+    IL_00d7:  ldc.i4.1
+    IL_00d8:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00dd:  call       int32 [netstandard]System.Decimal::Compare(valuetype [netstandard]System.Decimal,
+                                                                    valuetype [netstandard]System.Decimal)
+    IL_00e2:  pop
+    IL_00e3:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Decimal_comparison_RealInternalSignatureOn
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Decimal_comparison_RealInternalSignatureOn::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOn.fs.il.netcore.release.bsl b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOn.fs.il.netcore.release.bsl
new file mode 100644
index 00000000000..71cfc585372
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/EmittedIL/operators/decimal_comparison_RealInternalSignatureOn.fs.il.netcore.release.bsl
@@ -0,0 +1,275 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern netstandard
+{
+  .publickeytoken = (CC 7B 13 FF CD 2D DD 51 )                         
+  .ver 2:1:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.exe
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed Decimal_comparison_RealInternalSignatureOn
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$Decimal_comparison_RealInternalSignatureOn::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$Decimal_comparison_RealInternalSignatureOn::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.s   10
+    IL_0002:  ldc.i4.0
+    IL_0003:  ldc.i4.0
+    IL_0004:  ldc.i4.0
+    IL_0005:  ldc.i4.1
+    IL_0006:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_000b:  ldc.i4.s   20
+    IL_000d:  ldc.i4.0
+    IL_000e:  ldc.i4.0
+    IL_000f:  ldc.i4.0
+    IL_0010:  ldc.i4.1
+    IL_0011:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0016:  call       bool [netstandard]System.Decimal::op_LessThan(valuetype [netstandard]System.Decimal,
+                                                                       valuetype [netstandard]System.Decimal)
+    IL_001b:  pop
+    IL_001c:  ldc.i4.s   10
+    IL_001e:  ldc.i4.0
+    IL_001f:  ldc.i4.0
+    IL_0020:  ldc.i4.0
+    IL_0021:  ldc.i4.1
+    IL_0022:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0027:  ldc.i4.s   20
+    IL_0029:  ldc.i4.0
+    IL_002a:  ldc.i4.0
+    IL_002b:  ldc.i4.0
+    IL_002c:  ldc.i4.1
+    IL_002d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0032:  call       bool [netstandard]System.Decimal::op_LessThanOrEqual(valuetype [netstandard]System.Decimal,
+                                                                              valuetype [netstandard]System.Decimal)
+    IL_0037:  pop
+    IL_0038:  ldc.i4.s   10
+    IL_003a:  ldc.i4.0
+    IL_003b:  ldc.i4.0
+    IL_003c:  ldc.i4.0
+    IL_003d:  ldc.i4.1
+    IL_003e:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0043:  ldc.i4.s   20
+    IL_0045:  ldc.i4.0
+    IL_0046:  ldc.i4.0
+    IL_0047:  ldc.i4.0
+    IL_0048:  ldc.i4.1
+    IL_0049:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_004e:  call       bool [netstandard]System.Decimal::op_GreaterThan(valuetype [netstandard]System.Decimal,
+                                                                          valuetype [netstandard]System.Decimal)
+    IL_0053:  pop
+    IL_0054:  ldc.i4.s   10
+    IL_0056:  ldc.i4.0
+    IL_0057:  ldc.i4.0
+    IL_0058:  ldc.i4.0
+    IL_0059:  ldc.i4.1
+    IL_005a:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_005f:  ldc.i4.s   20
+    IL_0061:  ldc.i4.0
+    IL_0062:  ldc.i4.0
+    IL_0063:  ldc.i4.0
+    IL_0064:  ldc.i4.1
+    IL_0065:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_006a:  call       bool [netstandard]System.Decimal::op_GreaterThanOrEqual(valuetype [netstandard]System.Decimal,
+                                                                                 valuetype [netstandard]System.Decimal)
+    IL_006f:  pop
+    IL_0070:  ldc.i4.s   10
+    IL_0072:  ldc.i4.0
+    IL_0073:  ldc.i4.0
+    IL_0074:  ldc.i4.0
+    IL_0075:  ldc.i4.1
+    IL_0076:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_007b:  ldc.i4.s   20
+    IL_007d:  ldc.i4.0
+    IL_007e:  ldc.i4.0
+    IL_007f:  ldc.i4.0
+    IL_0080:  ldc.i4.1
+    IL_0081:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0086:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                       valuetype [netstandard]System.Decimal)
+    IL_008b:  pop
+    IL_008c:  ldc.i4.s   10
+    IL_008e:  ldc.i4.0
+    IL_008f:  ldc.i4.0
+    IL_0090:  ldc.i4.0
+    IL_0091:  ldc.i4.1
+    IL_0092:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_0097:  ldc.i4.s   20
+    IL_0099:  ldc.i4.0
+    IL_009a:  ldc.i4.0
+    IL_009b:  ldc.i4.0
+    IL_009c:  ldc.i4.1
+    IL_009d:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00a2:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                       valuetype [netstandard]System.Decimal)
+    IL_00a7:  ldc.i4.0
+    IL_00a8:  ceq
+    IL_00aa:  pop
+    IL_00ab:  ldc.i4.s   10
+    IL_00ad:  ldc.i4.0
+    IL_00ae:  ldc.i4.0
+    IL_00af:  ldc.i4.0
+    IL_00b0:  ldc.i4.1
+    IL_00b1:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00b6:  ldc.i4.s   20
+    IL_00b8:  ldc.i4.0
+    IL_00b9:  ldc.i4.0
+    IL_00ba:  ldc.i4.0
+    IL_00bb:  ldc.i4.1
+    IL_00bc:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00c1:  call       bool [netstandard]System.Decimal::op_Equality(valuetype [netstandard]System.Decimal,
+                                                                       valuetype [netstandard]System.Decimal)
+    IL_00c6:  pop
+    IL_00c7:  ldc.i4.s   10
+    IL_00c9:  ldc.i4.0
+    IL_00ca:  ldc.i4.0
+    IL_00cb:  ldc.i4.0
+    IL_00cc:  ldc.i4.1
+    IL_00cd:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00d2:  ldc.i4.s   20
+    IL_00d4:  ldc.i4.0
+    IL_00d5:  ldc.i4.0
+    IL_00d6:  ldc.i4.0
+    IL_00d7:  ldc.i4.1
+    IL_00d8:  newobj     instance void [netstandard]System.Decimal::.ctor(int32,
+                                                                          int32,
+                                                                          int32,
+                                                                          bool,
+                                                                          uint8)
+    IL_00dd:  call       int32 [netstandard]System.Decimal::Compare(valuetype [netstandard]System.Decimal,
+                                                                    valuetype [netstandard]System.Decimal)
+    IL_00e2:  pop
+    IL_00e3:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$Decimal_comparison_RealInternalSignatureOn
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void Decimal_comparison_RealInternalSignatureOn::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj b/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj
index ebfe6938aa8..38937398473 100644
--- a/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj
+++ b/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj
@@ -131,6 +131,13 @@
     <Compile Include="EmittedIL\Enums.fs" />
     <Compile Include="EmittedIL\Literals.fs" />
     <Compile Include="EmittedIL\NoCompilerInlining.fs" />
+    <Compile Include="EmittedIL\RealInternalSignature\ModuleVisibility.fs" />
+    <Compile Include="EmittedIL\RealInternalSignature\ModuleInitialization.fs" />
+    <Compile Include="EmittedIL\RealInternalSignature\ClassTypeVisibilityNamespaceRootWithFsi.fs" />
+    <Compile Include="EmittedIL\RealInternalSignature\ClassTypeVisibilityNamespaceRoot.fs" />
+    <Compile Include="EmittedIL\RealInternalSignature\ClassTypeVisibilityModuleRootWithFsi.fs" />
+    <Compile Include="EmittedIL\RealInternalSignature\ClassTypeVisibilityModuleRoot.fs" />
+    <Compile Include="EmittedIL\RealInternalSignature\ClassTypeInitialization.fs" />
     <Compile Include="EmittedIL\SkipLocalsInit.fs" />
     <Compile Include="EmittedIL\StringFormatAndInterpolation.fs" />
     <!--<Compile Include="EmittedIL\StructGettersReadOnly.fs" />-->
@@ -146,7 +153,8 @@
     <Compile Include="EmittedIL\CompiledNameAttribute\CompiledNameAttribute.fs" />
     <Compile Include="EmittedIL\ComputationExpressions\ComputationExpressions.fs" />
     <Compile Include="EmittedIL\DoNotBoxStruct\DoNotBoxStruct.fs" />
-    <Compile Include="EmittedIL\ForLoop\ForLoop.fs" />
+    <Compile Include="EmittedIL\ForLoop\RealInternalSignatureOff\ForLoop.fs" />
+    <Compile Include="EmittedIL\ForLoop\RealInternalSignatureOn\ForLoop.fs" />
     <Compile Include="EmittedIL\GeneratedIterators\GeneratedIterators.fs" />
     <Compile Include="EmittedIL\GenericComparison\GenericComparison.fs" />
     <Compile Include="EmittedIL\InequalityComparison\InequalityComparison.fs" />
@@ -249,7 +257,7 @@
     <Compile Include="TypeChecks\Graph\GraphProcessingTests.fs" />
     <Compile Include="TypeChecks\TyparNameTests.fs" />
     <Compile Include="TypeChecks\CheckTypeTests.fs" />
-    <Compile Include="TypeChecks\TypeExtensions\PropertyShadowingTests.fs" />
+    <Compile Include="TypeChecks\PropertyShadowingTests.fs" />
     <Compile Include="CompilerOptions\fsc\checked\checked.fs" />
     <Compile Include="CompilerOptions\fsc\cliversion.fs" />
     <Compile Include="CompilerOptions\fsc\codepage\codepage.fs" />
diff --git a/tests/FSharp.Compiler.ComponentTests/FSharpChecker/TransparentCompiler.fs b/tests/FSharp.Compiler.ComponentTests/FSharpChecker/TransparentCompiler.fs
index 3a8730043a3..5dc3dedb548 100644
--- a/tests/FSharp.Compiler.ComponentTests/FSharpChecker/TransparentCompiler.fs
+++ b/tests/FSharp.Compiler.ComponentTests/FSharpChecker/TransparentCompiler.fs
@@ -960,3 +960,54 @@ let ``Background compiler and Transparent compiler return the same options`` ()
         Assert.Equal<string list>(backgroundSnapshot.OtherOptions, transparentSnapshot.OtherOptions)
         Assert.Equal<ProjectSnapshot.ReferenceOnDisk list>(backgroundSnapshot.ReferencesOnDisk, transparentSnapshot.ReferencesOnDisk)
     }
+
+[<Theory>]
+[<InlineData(false)>]
+[<InlineData(true)>]
+let ``Unused warning should still produce after parse warning`` useTransparentCompiler =
+
+    // There should be parse warning because of the space in the file name:
+    //   warning FS0221: The declarations in this file will be placed in an implicit module 'As 01' based on the file name 'As 01.fs'.
+    //   However this is not a valid F# identifier, so the contents will not be accessible from other files. Consider renaming the file or adding a 'module' or 'namespace' declaration at the top of the file.
+    
+    let project =
+        { SyntheticProject.Create(
+            { sourceFile "As 01" [] with
+                Source = """
+do
+    let _ as b = ()
+    ()
+
+// For more information see https://aka.ms/fsharp-console-apps
+printfn "Hello from F#"
+"""
+                SignatureFile = No
+                
+            }) with
+            AutoAddModules = false
+            OtherOptions = [
+                "--target:exe"
+                "--warn:3"
+                "--warnon:1182"
+                "--warnaserror:3239"
+                "--noframework"
+            ]
+        }
+
+    let expectTwoWarnings (_parseResult:FSharpParseFileResults, checkAnswer: FSharpCheckFileAnswer) (_, _) =
+        match checkAnswer with
+        | FSharpCheckFileAnswer.Aborted -> failwith "Should not have aborted"
+        | FSharpCheckFileAnswer.Succeeded checkResults ->
+            let hasParseWarning =
+                checkResults.Diagnostics
+                |> Array.exists (fun diag -> diag.Severity = FSharpDiagnosticSeverity.Warning && diag.ErrorNumber = 221)
+            Assert.True(hasParseWarning, "Expected parse warning FS0221")
+
+            let hasCheckWarning =
+                checkResults.Diagnostics
+                |> Array.exists (fun diag -> diag.Severity = FSharpDiagnosticSeverity.Warning && diag.ErrorNumber = 1182)
+            Assert.True(hasCheckWarning, "Expected post inference warning FS1182")
+    
+    ProjectWorkflowBuilder(project, useTransparentCompiler = useTransparentCompiler) {
+        checkFile "As 01" expectTwoWarnings
+    }
diff --git a/tests/FSharp.Compiler.ComponentTests/Language/InterpolatedStringsTests.fs b/tests/FSharp.Compiler.ComponentTests/Language/InterpolatedStringsTests.fs
index 7c82ac3d88e..856c5d46d3c 100644
--- a/tests/FSharp.Compiler.ComponentTests/Language/InterpolatedStringsTests.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Language/InterpolatedStringsTests.fs
@@ -70,7 +70,7 @@ printfn \"%s\" s"
         |> withLangVersion80
         |> compile
         |> shouldFail
-        |> withSingleDiagnostic (Error 1249, Line 1, Col 15, Line 1, Col 21, "The interpolated string contains unmatched closing braces.")
+        |> withSingleDiagnostic (Error 1249, Line 1, Col 14, Line 1, Col 21, "The interpolated string contains unmatched closing braces.")
 
     [<Fact>]
     let ``Percent sign characters in interpolated strings`` () =
diff --git a/tests/FSharp.Compiler.ComponentTests/Miscellaneous/FsharpSuiteMigrated.fs b/tests/FSharp.Compiler.ComponentTests/Miscellaneous/FsharpSuiteMigrated.fs
index 79f3b1fc25e..868136e3205 100644
--- a/tests/FSharp.Compiler.ComponentTests/Miscellaneous/FsharpSuiteMigrated.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Miscellaneous/FsharpSuiteMigrated.fs
@@ -31,7 +31,7 @@ module ScriptRunner =
         let cu  = cu |> withDefines defaultDefines
         match cu with 
         | FS fsSource ->
-            File.Delete("test.ok")           
+            File.Delete("test.ok")
             let engine = createEngine (fsSource.Options |> Array.ofList,version)
             let res = evalScriptFromDiskInSharedSession engine cu
             match res with
diff --git a/tests/FSharp.Compiler.ComponentTests/Miscellaneous/MigratedCoreTests.fs b/tests/FSharp.Compiler.ComponentTests/Miscellaneous/MigratedCoreTests.fs
index 6ff282164e5..e92ef88592c 100644
--- a/tests/FSharp.Compiler.ComponentTests/Miscellaneous/MigratedCoreTests.fs
+++ b/tests/FSharp.Compiler.ComponentTests/Miscellaneous/MigratedCoreTests.fs
@@ -211,7 +211,7 @@ let ``nested-FSI`` () = singleTestBuildAndRun "core/nested" FSI
 let ``members-basics-hw`` () = singleTestBuildAndRun "core/members/basics-hw" FSC_OPTIMIZED
 
 [<FactForDESKTOP>]
-let ``members-basics-hw-mutrec`` () = singleTestBuildAndRun "core/members/basics-hw-mutrec" FSC_OPTIMIZED
+let ``members-basics-hw-mutrec-realinternalsignature`` () = singleTestBuildAndRun "core/members/basics-hw-mutrec" FSC_DEBUG//OPTIMIZED
 
 [<FactForDESKTOP>]
 let ``members-incremental-FSC_OPTIMIZED`` () = singleTestBuildAndRun "core/members/incremental" FSC_OPTIMIZED
@@ -366,16 +366,6 @@ let ``test int32-FSC_OPTIMIZED`` () = singleTestBuildAndRun "core/int32" FSC_OPT
 [<Fact>]
 let ``test int32-FSI`` () = singleTestBuildAndRun "core/int32" FSI
 
-// This test stays in FsharpSuite for desktop framework for a later migration phases, it uses hardcoded #r to a C# compiled cslib.dll inside
-[<FactForNETCOREAPP>]
-let ``quotes-FSC-FSC_DEBUG`` () = singleTestBuildAndRun "core/quotes" FSC_DEBUG
-
-[<FactForNETCOREAPP>]
-let ``quotes-FSC-BASIC`` () = singleTestBuildAndRun "core/quotes" FSC_OPTIMIZED
-
-[<FactForNETCOREAPP>]
-let ``quotes-FSI-BASIC`` () = singleTestBuildAndRun "core/quotes" FSI
-
 [<Fact>]
 let ``recordResolution-FSC_DEBUG`` () = singleTestBuildAndRun "core/recordResolution" FSC_DEBUG
 
diff --git a/tests/FSharp.Compiler.ComponentTests/Signatures/TestCasesForGenerationRoundTrip/access.fsx b/tests/FSharp.Compiler.ComponentTests/Signatures/TestCasesForGenerationRoundTrip/access.fsx
index 6c067a82125..5051e238db5 100644
--- a/tests/FSharp.Compiler.ComponentTests/Signatures/TestCasesForGenerationRoundTrip/access.fsx
+++ b/tests/FSharp.Compiler.ComponentTests/Signatures/TestCasesForGenerationRoundTrip/access.fsx
@@ -248,25 +248,25 @@ module RestrictedRecordsAndUnionsUsingPrivateAndInternalTypes =
                     
             let public getInt (data:Data): int = HelperModule.handle data.Thing               
 
-    module Test7 = 
-        module internal HelperModule = 
-            
-            type Data = 
-                    {
-                        Datum: int
-                    }
-                    
-            let handle (data:Data): int = data.Datum
-            
-        module Module =
-            
-            type Data = 
-                internal
-                    {
-                        Thing: HelperModule.Data
-                    }
-                    
-            let getInt (data:Data): int = HelperModule.handle data.Thing               
+//    module Test7 = 
+//        module internal HelperModule = 
+//            
+//            type Data = 
+//                    {
+//                        Datum: int
+//                    }
+//                    
+//            let handle (data:Data): int = data.Datum
+//            
+//        module Module =
+//            
+//            type Data = 
+//                internal
+//                    {
+//                        Thing: HelperModule.Data
+//                    }
+//                    
+//            let getInt (data:Data): int = HelperModule.handle data.Thing               
 
 
     (*--------------------*)  
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Graph/Scenarios.fs b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Graph/Scenarios.fs
index 524556dae0a..4b85f0cd808 100644
--- a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Graph/Scenarios.fs
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Graph/Scenarios.fs
@@ -796,8 +796,7 @@ type Foo = class end
                 sourceFile
                     "Program"
                     """
-module Program
-
+module RunMe
 printfn "Hello"
 """
                     Set.empty
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/PropertyShadowingTests.fs b/tests/FSharp.Compiler.ComponentTests/TypeChecks/PropertyShadowingTests.fs
new file mode 100644
index 00000000000..f74a6c951b7
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/PropertyShadowingTests.fs
@@ -0,0 +1,118 @@
+namespace EmittedIL.RealInternalSignature
+open Xunit
+open FSharp.Test
+open FSharp.Test.Compiler
+
+module PropertyShadowingTests =
+
+    let [<Literal>] folder = __SOURCE_DIRECTORY__ + "/Shadowing"
+
+    [<Theory;
+        Directory(
+        folder
+        , Includes=[|
+            "ShadowWithExtensionMethod.fsx"
+            "ShadowWithTypeExtension.fsx"
+            "ShadowingAndStillOkWithChainedCalls.fsx"
+            "LinqCount.fsx"
+            "ShadowStaticProperty.fsx"
+            "ShadowWithLastOpenedTypeExtensions.fsx"
+        |]
+        , BaselineSuffix = ".realInternalSignatureOff"
+    )>]
+    let ``can hide property - realInternalSignatureOff`` compilation =
+        compilation
+        |> asFsx
+        |> withNoDebug
+        |> withOptions ["--langversion:preview"]
+        |> withRealInternalSignatureOff
+        |> verifyBaselines
+        |> compileAndRun
+        |> shouldSucceed
+
+    [<Theory;
+        Directory(
+        folder
+        , Includes=[|
+            "ShadowWithExtensionMethod.fsx"
+            "ShadowWithTypeExtension.fsx"
+            "ShadowingAndStillOkWithChainedCalls.fsx"
+            "LinqCount.fsx"
+            "ShadowStaticProperty.fsx"
+            "ShadowWithLastOpenedTypeExtensions.fsx"
+        |]
+        , BaselineSuffix = ".realInternalSignatureOn"
+    )>]
+    let ``can hide property - realInternalSignatureOn`` compilation =
+        compilation
+        |> asFsx
+        |> withNoDebug
+        |> withOptions ["--langversion:preview"]
+        |> withRealInternalSignatureOn
+        |> verifyBaselines
+        |> compileAndRun
+        |> shouldSucceed
+
+
+    [<Theory;
+        Directory(
+            folder
+            , Includes = [|
+            "ShadowWithExtensionMethod.fsx"
+            "ShadowWithTypeExtension.fsx"
+            "ShadowingAndStillOkWithChainedCalls.fsx"
+            "LinqCount.fsx"
+            "ShadowStaticProperty.fsx"
+            "ShadowWithLastOpenedTypeExtensions.fsx"
+            |]
+            , BaselineSuffix = ".support.added.later"
+    )>]
+    let ``cannot hide property v7_0 support added later`` compilation =
+        compilation
+        |> asFsx
+        |> withNoDebug
+        |> withOptions ["--langversion:7.0"]
+        |> verifyBaselines
+        |> compile
+        |> shouldFail
+
+    [<Theory;
+        Directory(
+        folder
+        , Includes=[|
+            "E_CannotShadowIndexedPropertyWithExtensionMethod.fsx"
+            "E_CannotShadowIndexedPropertyWithTypeExtension.fsx"
+            "E_CannotShadowFunctionPropertyWithExtensionMethod.fsx"
+            "E_CannotShadowFunctionPropertyWithTypeExtension.fsx"
+            "E_NoChangeForEvent.fsx"
+        |]
+    )>]
+    let ``cannot hide property`` compilation =
+        compilation
+        |> asFsx
+        |> withNoDebug
+        |> withOptions ["--langversion:preview"]
+        |> verifyBaselines
+        |> compile
+        |> shouldFail
+    
+
+    [<Theory;
+        Directory(
+        folder
+        , Includes=[|
+            "E_CannotShadowIndexedPropertyWithExtensionMethod.fsx"
+            "E_CannotShadowIndexedPropertyWithTypeExtension.fsx"
+            "E_CannotShadowFunctionPropertyWithExtensionMethod.fsx"
+            "E_CannotShadowFunctionPropertyWithTypeExtension.fsx"
+            "E_NoChangeForEvent.fsx"
+        |]
+    )>]
+    let ``cannot hide property v7_0`` compilation =
+        compilation
+        |> asFsx
+        |> withNoDebug
+        |> withOptions ["--langversion:7.0"]
+        |> verifyBaselines
+        |> compile
+        |> shouldFail
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowFunctionPropertyWithExtensionMethod.fsx b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowFunctionPropertyWithExtensionMethod.fsx
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowFunctionPropertyWithExtensionMethod.fsx
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowFunctionPropertyWithExtensionMethod.fsx
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowFunctionPropertyWithExtensionMethod.fsx.err.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowFunctionPropertyWithExtensionMethod.fsx.err.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowFunctionPropertyWithExtensionMethod.fsx.err.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowFunctionPropertyWithExtensionMethod.fsx.err.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowFunctionPropertyWithExtensionMethod.fsx.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowFunctionPropertyWithExtensionMethod.fsx.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowFunctionPropertyWithExtensionMethod.fsx.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowFunctionPropertyWithExtensionMethod.fsx.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowFunctionPropertyWithTypeExtension.fsx b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowFunctionPropertyWithTypeExtension.fsx
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowFunctionPropertyWithTypeExtension.fsx
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowFunctionPropertyWithTypeExtension.fsx
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowFunctionPropertyWithTypeExtension.fsx.err.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowFunctionPropertyWithTypeExtension.fsx.err.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowFunctionPropertyWithTypeExtension.fsx.err.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowFunctionPropertyWithTypeExtension.fsx.err.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowFunctionPropertyWithTypeExtension.fsx.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowFunctionPropertyWithTypeExtension.fsx.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowFunctionPropertyWithTypeExtension.fsx.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowFunctionPropertyWithTypeExtension.fsx.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowIndexedPropertyWithExtensionMethod.fsx b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowIndexedPropertyWithExtensionMethod.fsx
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowIndexedPropertyWithExtensionMethod.fsx
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowIndexedPropertyWithExtensionMethod.fsx
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowIndexedPropertyWithExtensionMethod.fsx.err.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowIndexedPropertyWithExtensionMethod.fsx.err.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowIndexedPropertyWithExtensionMethod.fsx.err.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowIndexedPropertyWithExtensionMethod.fsx.err.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowIndexedPropertyWithExtensionMethod.fsx.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowIndexedPropertyWithExtensionMethod.fsx.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowIndexedPropertyWithExtensionMethod.fsx.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowIndexedPropertyWithExtensionMethod.fsx.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowIndexedPropertyWithTypeExtension.fsx b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowIndexedPropertyWithTypeExtension.fsx
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowIndexedPropertyWithTypeExtension.fsx
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowIndexedPropertyWithTypeExtension.fsx
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowIndexedPropertyWithTypeExtension.fsx.err.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowIndexedPropertyWithTypeExtension.fsx.err.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowIndexedPropertyWithTypeExtension.fsx.err.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowIndexedPropertyWithTypeExtension.fsx.err.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowIndexedPropertyWithTypeExtension.fsx.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowIndexedPropertyWithTypeExtension.fsx.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_CannotShadowIndexedPropertyWithTypeExtension.fsx.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_CannotShadowIndexedPropertyWithTypeExtension.fsx.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_NoChangeForEvent.fsx b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_NoChangeForEvent.fsx
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_NoChangeForEvent.fsx
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_NoChangeForEvent.fsx
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_NoChangeForEvent.fsx.err.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_NoChangeForEvent.fsx.err.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_NoChangeForEvent.fsx.err.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_NoChangeForEvent.fsx.err.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_NoChangeForEvent.fsx.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_NoChangeForEvent.fsx.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/E_NoChangeForEvent.fsx.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/E_NoChangeForEvent.fsx.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/LinqCount.fsx b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/LinqCount.fsx
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/LinqCount.fsx.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/LinqCount.fsx.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/LinqCount.fsx.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.il.net472.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/LinqCount.fsx.il.net472.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.il.net472.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/LinqCount.fsx.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.il.netcore.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/LinqCount.fsx.il.netcore.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.il.netcore.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.realInternalSignatureOff.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.realInternalSignatureOff.il.net472.bsl
new file mode 100644
index 00000000000..9a1fec0d897
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.realInternalSignatureOff.il.net472.bsl
@@ -0,0 +1,112 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern System.Core
+{
+  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         
+  .ver 4:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto autochar serializable sealed nested assembly beforefieldinit specialname clo@4
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method assembly static bool  Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.1
+      IL_0001:  ret
+    } 
+
+  } 
+
+  .method public specialname static class [runtime]System.Collections.Generic.List`1<int32> get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.List`1<int32> '<StartupCode$assembly>'.$assembly$fsx::r@2
+    IL_0005:  ret
+  } 
+
+  .property class [runtime]System.Collections.Generic.List`1<int32>
+          r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.List`1<int32> assembly::get_r()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly$fsx
+       extends [runtime]System.Object
+{
+  .field static assembly initonly class [runtime]System.Collections.Generic.List`1<int32> r@2
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  newobj     instance void class [runtime]System.Collections.Generic.List`1<int32>::.ctor()
+    IL_0005:  stsfld     class [runtime]System.Collections.Generic.List`1<int32> '<StartupCode$assembly>'.$assembly$fsx::r@2
+    IL_000a:  call       class [runtime]System.Collections.Generic.List`1<int32> assembly::get_r()
+    IL_000f:  callvirt   instance int32 class [runtime]System.Collections.Generic.List`1<int32>::get_Count()
+    IL_0014:  pop
+    IL_0015:  call       class [runtime]System.Collections.Generic.List`1<int32> assembly::get_r()
+    IL_001a:  ldnull
+    IL_001b:  ldftn      bool assembly/clo@4::Invoke(int32)
+    IL_0021:  newobj     instance void class [runtime]System.Func`2<int32,bool>::.ctor(object,
+                                                                                        native int)
+    IL_0026:  call       int32 [System.Core]System.Linq.Enumerable::Count<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                 class [runtime]System.Func`2<!!0,bool>)
+    IL_002b:  pop
+    IL_002c:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.realInternalSignatureOff.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.realInternalSignatureOff.il.netcore.bsl
new file mode 100644
index 00000000000..4504a6f2f5f
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.realInternalSignatureOff.il.netcore.bsl
@@ -0,0 +1,117 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern System.Collections
+{
+  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         
+  .ver 8:0:0:0
+}
+.assembly extern System.Linq
+{
+  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         
+  .ver 8:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto autochar serializable sealed nested assembly beforefieldinit specialname clo@4
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method assembly static bool  Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.1
+      IL_0001:  ret
+    } 
+
+  } 
+
+  .method public specialname static class [System.Collections]System.Collections.Generic.List`1<int32> get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [System.Collections]System.Collections.Generic.List`1<int32> '<StartupCode$assembly>'.$assembly$fsx::r@2
+    IL_0005:  ret
+  } 
+
+  .property class [System.Collections]System.Collections.Generic.List`1<int32>
+          r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [System.Collections]System.Collections.Generic.List`1<int32> assembly::get_r()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly$fsx
+       extends [runtime]System.Object
+{
+  .field static assembly initonly class [System.Collections]System.Collections.Generic.List`1<int32> r@2
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  newobj     instance void class [System.Collections]System.Collections.Generic.List`1<int32>::.ctor()
+    IL_0005:  stsfld     class [System.Collections]System.Collections.Generic.List`1<int32> '<StartupCode$assembly>'.$assembly$fsx::r@2
+    IL_000a:  call       class [System.Collections]System.Collections.Generic.List`1<int32> assembly::get_r()
+    IL_000f:  callvirt   instance int32 class [System.Collections]System.Collections.Generic.List`1<int32>::get_Count()
+    IL_0014:  pop
+    IL_0015:  call       class [System.Collections]System.Collections.Generic.List`1<int32> assembly::get_r()
+    IL_001a:  ldnull
+    IL_001b:  ldftn      bool assembly/clo@4::Invoke(int32)
+    IL_0021:  newobj     instance void class [runtime]System.Func`2<int32,bool>::.ctor(object,
+                                                                                              native int)
+    IL_0026:  call       int32 [System.Linq]System.Linq.Enumerable::Count<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                 class [runtime]System.Func`2<!!0,bool>)
+    IL_002b:  pop
+    IL_002c:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.realInternalSignatureOn.il.net472.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.realInternalSignatureOn.il.net472.bsl
new file mode 100644
index 00000000000..53e00c11f9c
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.realInternalSignatureOn.il.net472.bsl
@@ -0,0 +1,131 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern System.Core
+{
+  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         
+  .ver 4:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto autochar serializable sealed nested assembly beforefieldinit specialname clo@4
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method assembly static bool  Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.1
+      IL_0001:  ret
+    } 
+
+  } 
+
+  .field static assembly class [runtime]System.Collections.Generic.List`1<int32> r@2
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [runtime]System.Collections.Generic.List`1<int32> get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [runtime]System.Collections.Generic.List`1<int32> assembly::r@2
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  newobj     instance void class [runtime]System.Collections.Generic.List`1<int32>::.ctor()
+    IL_0005:  stsfld     class [runtime]System.Collections.Generic.List`1<int32> assembly::r@2
+    IL_000a:  call       class [runtime]System.Collections.Generic.List`1<int32> assembly::get_r()
+    IL_000f:  callvirt   instance int32 class [runtime]System.Collections.Generic.List`1<int32>::get_Count()
+    IL_0014:  pop
+    IL_0015:  call       class [runtime]System.Collections.Generic.List`1<int32> assembly::get_r()
+    IL_001a:  ldnull
+    IL_001b:  ldftn      bool assembly/clo@4::Invoke(int32)
+    IL_0021:  newobj     instance void class [runtime]System.Func`2<int32,bool>::.ctor(object,
+                                                                                        native int)
+    IL_0026:  call       int32 [System.Core]System.Linq.Enumerable::Count<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                 class [runtime]System.Func`2<!!0,bool>)
+    IL_002b:  pop
+    IL_002c:  ret
+  } 
+
+  .property class [runtime]System.Collections.Generic.List`1<int32>
+          r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [runtime]System.Collections.Generic.List`1<int32> assembly::get_r()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly$fsx
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.realInternalSignatureOn.il.netcore.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.realInternalSignatureOn.il.netcore.bsl
new file mode 100644
index 00000000000..93f09f050af
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.realInternalSignatureOn.il.netcore.bsl
@@ -0,0 +1,136 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly extern System.Collections
+{
+  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         
+  .ver 8:0:0:0
+}
+.assembly extern System.Linq
+{
+  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         
+  .ver 8:0:0:0
+}
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class abstract auto autochar serializable sealed nested assembly beforefieldinit specialname clo@4
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 06 00 00 00 00 00 ) 
+    .method assembly static bool  Invoke(int32 _arg1) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.1
+      IL_0001:  ret
+    } 
+
+  } 
+
+  .field static assembly class [System.Collections]System.Collections.Generic.List`1<int32> r@2
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [System.Collections]System.Collections.Generic.List`1<int32> get_r() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [System.Collections]System.Collections.Generic.List`1<int32> assembly::r@2
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  newobj     instance void class [System.Collections]System.Collections.Generic.List`1<int32>::.ctor()
+    IL_0005:  stsfld     class [System.Collections]System.Collections.Generic.List`1<int32> assembly::r@2
+    IL_000a:  call       class [System.Collections]System.Collections.Generic.List`1<int32> assembly::get_r()
+    IL_000f:  callvirt   instance int32 class [System.Collections]System.Collections.Generic.List`1<int32>::get_Count()
+    IL_0014:  pop
+    IL_0015:  call       class [System.Collections]System.Collections.Generic.List`1<int32> assembly::get_r()
+    IL_001a:  ldnull
+    IL_001b:  ldftn      bool assembly/clo@4::Invoke(int32)
+    IL_0021:  newobj     instance void class [runtime]System.Func`2<int32,bool>::.ctor(object,
+                                                                                              native int)
+    IL_0026:  call       int32 [System.Linq]System.Linq.Enumerable::Count<int32>(class [runtime]System.Collections.Generic.IEnumerable`1<!!0>,
+                                                                                 class [runtime]System.Func`2<!!0,bool>)
+    IL_002b:  pop
+    IL_002c:  ret
+  } 
+
+  .property class [System.Collections]System.Collections.Generic.List`1<int32>
+          r()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [System.Collections]System.Collections.Generic.List`1<int32> assembly::get_r()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly$fsx
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/LinqCount.fsx.support.added.later.err.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.support.added.later.err.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/LinqCount.fsx.support.added.later.err.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.support.added.later.err.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/LinqCount.fsx.support.added.later.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.support.added.later.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/LinqCount.fsx.support.added.later.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/LinqCount.fsx.support.added.later.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowStaticProperty.fsx b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowStaticProperty.fsx
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowStaticProperty.fsx
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowStaticProperty.fsx
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowStaticProperty.fsx.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowStaticProperty.fsx.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowStaticProperty.fsx.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowStaticProperty.fsx.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowStaticProperty.fsx.realInternalSignatureOff.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowStaticProperty.fsx.realInternalSignatureOff.il.bsl
new file mode 100644
index 00000000000..cd96ae8b94e
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowStaticProperty.fsx.realInternalSignatureOff.il.bsl
@@ -0,0 +1,189 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public Foo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field static assembly int32 x
+    .field static assembly int32 init@1
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method public specialname static int32 get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 assembly/Foo::init@1
+      IL_0007:  ldc.i4.1
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldsfld     int32 assembly/Foo::x
+      IL_0016:  ret
+    } 
+
+    .method public specialname static void set_X(int32 v) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 assembly/Foo::init@1
+      IL_0007:  ldc.i4.1
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldarg.0
+      IL_0012:  stsfld     int32 assembly/Foo::x
+      IL_0017:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .property int32 X()
+    {
+      .set void assembly/Foo::set_X(int32)
+      .get int32 assembly/Foo::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public Exts2
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .method public static void  Foo.X.Static(int32 v) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldc.i4.2
+      IL_0002:  mul
+      IL_0003:  call       void assembly/Foo::set_X(int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class abstract auto ansi sealed nested public Exts
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .method public static void  Foo.X.Static(int32 v) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       void assembly/Foo::set_X(int32)
+      IL_0006:  ret
+    } 
+
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly$fsx
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 assembly/Foo::x
+    IL_0006:  ldc.i4.1
+    IL_0007:  volatile.
+    IL_0009:  stsfld     int32 assembly/Foo::init@1
+    IL_000e:  ldc.i4.1
+    IL_000f:  call       void assembly/Foo::set_X(int32)
+    IL_0014:  call       int32 assembly/Foo::get_X()
+    IL_0019:  ldc.i4.1
+    IL_001a:  beq.s      IL_0024
+
+    IL_001c:  ldc.i4.1
+    IL_001d:  call       void [runtime]System.Environment::Exit(int32)
+    IL_0022:  br.s       IL_0024
+
+    IL_0024:  ldc.i4.4
+    IL_0025:  call       void assembly/Foo::set_X(int32)
+    IL_002a:  call       int32 assembly/Foo::get_X()
+    IL_002f:  ldc.i4.4
+    IL_0030:  beq.s      IL_003a
+
+    IL_0032:  ldc.i4.2
+    IL_0033:  call       void [runtime]System.Environment::Exit(int32)
+    IL_0038:  br.s       IL_003a
+
+    IL_003a:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowStaticProperty.fsx.realInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowStaticProperty.fsx.realInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..4b50483a50b
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowStaticProperty.fsx.realInternalSignatureOn.il.bsl
@@ -0,0 +1,216 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public Foo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field static assembly int32 x
+    .field static assembly int32 init@1
+    .method private specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method public specialname static int32 get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 assembly/Foo::init@1
+      IL_0007:  ldc.i4.1
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldsfld     int32 assembly/Foo::x
+      IL_0016:  ret
+    } 
+
+    .method public specialname static void set_X(int32 v) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 assembly/Foo::init@1
+      IL_0007:  ldc.i4.1
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldarg.0
+      IL_0012:  stsfld     int32 assembly/Foo::x
+      IL_0017:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 assembly/Foo::x
+      IL_0006:  ldc.i4.1
+      IL_0007:  volatile.
+      IL_0009:  stsfld     int32 assembly/Foo::init@1
+      IL_000e:  ret
+    } 
+
+    .property int32 X()
+    {
+      .set void assembly/Foo::set_X(int32)
+      .get int32 assembly/Foo::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public Exts2
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .method public static void  Foo.X.Static(int32 v) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldc.i4.2
+      IL_0002:  mul
+      IL_0003:  call       void assembly/Foo::set_X(int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class abstract auto ansi sealed nested public Exts
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .method public static void  Foo.X.Static(int32 v) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       void assembly/Foo::set_X(int32)
+      IL_0006:  ret
+    } 
+
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly/Foo::staticInitialization@()
+    IL_0005:  ldc.i4.1
+    IL_0006:  call       void assembly/Foo::set_X(int32)
+    IL_000b:  call       int32 assembly/Foo::get_X()
+    IL_0010:  ldc.i4.1
+    IL_0011:  beq.s      IL_001b
+
+    IL_0013:  ldc.i4.1
+    IL_0014:  call       void [runtime]System.Environment::Exit(int32)
+    IL_0019:  br.s       IL_001b
+
+    IL_001b:  ldc.i4.4
+    IL_001c:  call       void assembly/Foo::set_X(int32)
+    IL_0021:  call       int32 assembly/Foo::get_X()
+    IL_0026:  ldc.i4.4
+    IL_0027:  beq.s      IL_0031
+
+    IL_0029:  ldc.i4.2
+    IL_002a:  call       void [runtime]System.Environment::Exit(int32)
+    IL_002f:  br.s       IL_0031
+
+    IL_0031:  ret
+  } 
+
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly$fsx
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowStaticProperty.fsx.support.added.later.err.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowStaticProperty.fsx.support.added.later.err.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowStaticProperty.fsx.support.added.later.err.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowStaticProperty.fsx.support.added.later.err.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowStaticProperty.fsx.support.added.later.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowStaticProperty.fsx.support.added.later.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowStaticProperty.fsx.support.added.later.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowStaticProperty.fsx.support.added.later.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithExtensionMethod.fsx b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithExtensionMethod.fsx
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithExtensionMethod.fsx
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithExtensionMethod.fsx
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithExtensionMethod.fsx.err.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithExtensionMethod.fsx.err.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithExtensionMethod.fsx.err.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithExtensionMethod.fsx.err.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithExtensionMethod.fsx.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithExtensionMethod.fsx.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithExtensionMethod.fsx.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithExtensionMethod.fsx.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithExtensionMethod.fsx.realInternalSignatureOff.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithExtensionMethod.fsx.realInternalSignatureOff.il.bsl
new file mode 100644
index 00000000000..e19df3fd009
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithExtensionMethod.fsx.realInternalSignatureOff.il.bsl
@@ -0,0 +1,222 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public Foo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly int32 X@
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldc.i4.0
+      IL_000a:  stfld      int32 assembly/Foo::X@
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_X() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/Foo::X@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname instance void  set_X(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 assembly/Foo::X@
+      IL_0007:  ret
+    } 
+
+    .property instance int32 X()
+    {
+      .set instance void assembly/Foo::set_X(int32)
+      .get instance int32 assembly/Foo::get_X()
+    } 
+  } 
+
+  .class auto ansi serializable nested public FooExt
+         extends [runtime]System.Object
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.ExtensionAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public static class assembly/Foo 
+            X(class assembly/Foo f,
+              int32 i) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.ExtensionAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 assembly/Foo::X@
+      IL_0007:  ldarg.0
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .method public specialname static class assembly/Foo get_f() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::f@12
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class assembly/Foo get_f@9() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::'f@9-1'
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class assembly/Foo 'get_f@9-1'() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::'f@9-2'
+    IL_0005:  ret
+  } 
+
+  .property class assembly/Foo
+          f()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::get_f()
+  } 
+  .property class assembly/Foo
+          f@9()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::get_f@9()
+  } 
+  .property class assembly/Foo
+          'f@9-1'()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::'get_f@9-1'()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly$fsx
+       extends [runtime]System.Object
+{
+  .field static assembly initonly class assembly/Foo f@12
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly initonly class assembly/Foo 'f@9-1'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly initonly class assembly/Foo 'f@9-2'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  4
+    IL_0000:  newobj     instance void assembly/Foo::.ctor()
+    IL_0005:  stsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::f@12
+    IL_000a:  call       class assembly/Foo assembly::get_f()
+    IL_000f:  ldc.i4.1
+    IL_0010:  stfld      int32 assembly/Foo::X@
+    IL_0015:  call       class assembly/Foo assembly::get_f()
+    IL_001a:  pop
+    IL_001b:  call       class assembly/Foo assembly::get_f()
+    IL_0020:  ldfld      int32 assembly/Foo::X@
+    IL_0025:  ldc.i4.1
+    IL_0026:  beq.s      IL_0030
+
+    IL_0028:  ldc.i4.1
+    IL_0029:  call       void [runtime]System.Environment::Exit(int32)
+    IL_002e:  br.s       IL_0030
+
+    IL_0030:  call       class assembly/Foo assembly::get_f()
+    IL_0035:  ldc.i4.1
+    IL_0036:  stfld      int32 assembly/Foo::X@
+    IL_003b:  call       class assembly/Foo assembly::get_f()
+    IL_0040:  stsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::'f@9-2'
+    IL_0045:  call       class assembly/Foo assembly::'get_f@9-1'()
+    IL_004a:  ldc.i4.2
+    IL_004b:  stfld      int32 assembly/Foo::X@
+    IL_0050:  call       class assembly/Foo assembly::'get_f@9-1'()
+    IL_0055:  stsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::'f@9-1'
+    IL_005a:  call       class assembly/Foo assembly::get_f@9()
+    IL_005f:  ldc.i4.3
+    IL_0060:  stfld      int32 assembly/Foo::X@
+    IL_0065:  call       class assembly/Foo assembly::get_f@9()
+    IL_006a:  pop
+    IL_006b:  call       class assembly/Foo assembly::get_f()
+    IL_0070:  ldfld      int32 assembly/Foo::X@
+    IL_0075:  ldc.i4.3
+    IL_0076:  beq.s      IL_0080
+
+    IL_0078:  ldc.i4.2
+    IL_0079:  call       void [runtime]System.Environment::Exit(int32)
+    IL_007e:  br.s       IL_0080
+
+    IL_0080:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithExtensionMethod.fsx.realInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithExtensionMethod.fsx.realInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..93ac1ea9b3e
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithExtensionMethod.fsx.realInternalSignatureOn.il.bsl
@@ -0,0 +1,241 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public Foo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly int32 X@
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldc.i4.0
+      IL_000a:  stfld      int32 assembly/Foo::X@
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_X() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/Foo::X@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname instance void  set_X(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 assembly/Foo::X@
+      IL_0007:  ret
+    } 
+
+    .property instance int32 X()
+    {
+      .set instance void assembly/Foo::set_X(int32)
+      .get instance int32 assembly/Foo::get_X()
+    } 
+  } 
+
+  .class auto ansi serializable nested public FooExt
+         extends [runtime]System.Object
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.ExtensionAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public static class assembly/Foo 
+            X(class assembly/Foo f,
+              int32 i) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.ExtensionAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 assembly/Foo::X@
+      IL_0007:  ldarg.0
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .field static assembly class assembly/Foo f@12
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class assembly/Foo 'f@9-1'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class assembly/Foo 'f@9-2'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class assembly/Foo get_f() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo assembly::f@12
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class assembly/Foo get_f@9() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo assembly::'f@9-1'
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class assembly/Foo 'get_f@9-1'() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo assembly::'f@9-2'
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    IL_0000:  newobj     instance void assembly/Foo::.ctor()
+    IL_0005:  stsfld     class assembly/Foo assembly::f@12
+    IL_000a:  call       class assembly/Foo assembly::get_f()
+    IL_000f:  ldc.i4.1
+    IL_0010:  stfld      int32 assembly/Foo::X@
+    IL_0015:  call       class assembly/Foo assembly::get_f()
+    IL_001a:  pop
+    IL_001b:  call       class assembly/Foo assembly::get_f()
+    IL_0020:  ldfld      int32 assembly/Foo::X@
+    IL_0025:  ldc.i4.1
+    IL_0026:  beq.s      IL_0030
+
+    IL_0028:  ldc.i4.1
+    IL_0029:  call       void [runtime]System.Environment::Exit(int32)
+    IL_002e:  br.s       IL_0030
+
+    IL_0030:  call       class assembly/Foo assembly::get_f()
+    IL_0035:  ldc.i4.1
+    IL_0036:  stfld      int32 assembly/Foo::X@
+    IL_003b:  call       class assembly/Foo assembly::get_f()
+    IL_0040:  stsfld     class assembly/Foo assembly::'f@9-2'
+    IL_0045:  call       class assembly/Foo assembly::'get_f@9-1'()
+    IL_004a:  ldc.i4.2
+    IL_004b:  stfld      int32 assembly/Foo::X@
+    IL_0050:  call       class assembly/Foo assembly::'get_f@9-1'()
+    IL_0055:  stsfld     class assembly/Foo assembly::'f@9-1'
+    IL_005a:  call       class assembly/Foo assembly::get_f@9()
+    IL_005f:  ldc.i4.3
+    IL_0060:  stfld      int32 assembly/Foo::X@
+    IL_0065:  call       class assembly/Foo assembly::get_f@9()
+    IL_006a:  pop
+    IL_006b:  call       class assembly/Foo assembly::get_f()
+    IL_0070:  ldfld      int32 assembly/Foo::X@
+    IL_0075:  ldc.i4.3
+    IL_0076:  beq.s      IL_0080
+
+    IL_0078:  ldc.i4.2
+    IL_0079:  call       void [runtime]System.Environment::Exit(int32)
+    IL_007e:  br.s       IL_0080
+
+    IL_0080:  ret
+  } 
+
+  .property class assembly/Foo
+          f()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::get_f()
+  } 
+  .property class assembly/Foo
+          f@9()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::get_f@9()
+  } 
+  .property class assembly/Foo
+          'f@9-1'()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::'get_f@9-1'()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly$fsx
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithExtensionMethod.fsx.support.added.later.err.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithExtensionMethod.fsx.support.added.later.err.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithExtensionMethod.fsx.support.added.later.err.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithExtensionMethod.fsx.support.added.later.err.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithExtensionMethod.fsx.support.added.later.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithExtensionMethod.fsx.support.added.later.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithExtensionMethod.fsx.support.added.later.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithExtensionMethod.fsx.support.added.later.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.err.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.err.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.err.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.err.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.realInternalSignatureOff.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.realInternalSignatureOff.il.bsl
new file mode 100644
index 00000000000..a0e89588014
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.realInternalSignatureOff.il.bsl
@@ -0,0 +1,571 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public Foo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field static assembly int32 x
+    .field static assembly int32 init@4
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method public specialname static int32 get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 assembly/Foo::init@4
+      IL_0007:  ldc.i4.1
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldsfld     int32 assembly/Foo::x
+      IL_0016:  ret
+    } 
+
+    .method public specialname static void set_X(int32 v) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 assembly/Foo::init@4
+      IL_0007:  ldc.i4.1
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldarg.0
+      IL_0012:  stsfld     int32 assembly/Foo::x
+      IL_0017:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .property int32 X()
+    {
+      .set void assembly/Foo::set_X(int32)
+      .get int32 assembly/Foo::get_X()
+    } 
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'todo1@20-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+  {
+    .field public valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'value'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'value') cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly/'todo1@20-1'::'value'
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> ctxt) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.0
+      IL_0002:  ldfld      valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly/'todo1@20-1'::'value'
+      IL_0007:  tail.
+      IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>::Success(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!0>,
+                                                                                                                                                                                                                                                                                !0)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'todo1@22-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+  {
+    .field public valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'value'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'value') cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly/'todo1@22-2'::'value'
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> ctxt) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.0
+      IL_0002:  ldfld      valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly/'todo1@22-2'::'value'
+      IL_0007:  tail.
+      IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>::Success(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!0>,
+                                                                                                                                                                                                                                                                                !0)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit todo1@18
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>>
+  {
+    .field static assembly initonly class assembly/todo1@18 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> V_0)
+      IL_0000:  ldc.i4.1
+      IL_0001:  call       void assembly/Foo::set_X(int32)
+      IL_0006:  call       int32 assembly/Foo::get_X()
+      IL_000b:  ldc.i4.1
+      IL_000c:  beq.s      IL_0023
+
+      IL_000e:  ldc.i4.1
+      IL_000f:  call       valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<!0,!1> valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::NewError(!1)
+      IL_0014:  stloc.0
+      IL_0015:  ldloc.0
+      IL_0016:  newobj     instance void assembly/'todo1@20-1'::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>)
+      IL_001b:  tail.
+      IL_001d:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+      IL_0022:  ret
+
+      IL_0023:  ldnull
+      IL_0024:  call       valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<!0,!1> valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::NewOk(!0)
+      IL_0029:  stloc.0
+      IL_002a:  ldloc.0
+      IL_002b:  newobj     instance void assembly/'todo1@22-2'::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>)
+      IL_0030:  tail.
+      IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+      IL_0037:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/todo1@18::.ctor()
+      IL_0005:  stsfld     class assembly/todo1@18 assembly/todo1@18::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'todo2@39-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+  {
+    .field public valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'value'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'value') cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly/'todo2@39-1'::'value'
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> ctxt) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.0
+      IL_0002:  ldfld      valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly/'todo2@39-1'::'value'
+      IL_0007:  tail.
+      IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>::Success(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!0>,
+                                                                                                                                                                                                                                                                                !0)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'todo2@41-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+  {
+    .field public valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'value'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'value') cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly/'todo2@41-2'::'value'
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> ctxt) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.0
+      IL_0002:  ldfld      valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly/'todo2@41-2'::'value'
+      IL_0007:  tail.
+      IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>::Success(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!0>,
+                                                                                                                                                                                                                                                                                !0)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit todo2@37
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>>
+  {
+    .field static assembly initonly class assembly/todo2@37 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> V_0)
+      IL_0000:  ldc.i4.2
+      IL_0001:  call       void assembly/Foo::set_X(int32)
+      IL_0006:  call       int32 assembly/Foo::get_X()
+      IL_000b:  ldc.i4.2
+      IL_000c:  beq.s      IL_0023
+
+      IL_000e:  ldc.i4.2
+      IL_000f:  call       valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<!0,!1> valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::NewError(!1)
+      IL_0014:  stloc.0
+      IL_0015:  ldloc.0
+      IL_0016:  newobj     instance void assembly/'todo2@39-1'::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>)
+      IL_001b:  tail.
+      IL_001d:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+      IL_0022:  ret
+
+      IL_0023:  ldnull
+      IL_0024:  call       valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<!0,!1> valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::NewOk(!0)
+      IL_0029:  stloc.0
+      IL_002a:  ldloc.0
+      IL_002b:  newobj     instance void assembly/'todo2@41-2'::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>)
+      IL_0030:  tail.
+      IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+      IL_0037:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/todo2@37::.ctor()
+      IL_0005:  stsfld     class assembly/todo2@37 assembly/todo2@37::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class abstract auto ansi sealed nested public Exts2
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .method public static void  Foo.X.Static(int32 v) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldc.i4.2
+      IL_0002:  mul
+      IL_0003:  call       void assembly/Foo::set_X(int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class abstract auto ansi sealed nested public Exts
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .method public static void  Foo.X.Static(int32 v) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       void assembly/Foo::set_X(int32)
+      IL_0006:  ret
+    } 
+
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> get_todo1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> '<StartupCode$assembly>'.$assembly$fsx::todo1@16
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> get_matchValue@25() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> '<StartupCode$assembly>'.$assembly$fsx::matchValue@25
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> get_computation@25() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> '<StartupCode$assembly>'.$assembly$fsx::computation@25
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> get_todo2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> '<StartupCode$assembly>'.$assembly$fsx::todo2@35
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'get_matchValue@44-1'() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> '<StartupCode$assembly>'.$assembly$fsx::'matchValue@44-1'
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> 'get_computation@44-1'() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> '<StartupCode$assembly>'.$assembly$fsx::'computation@44-1'
+    IL_0005:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>
+          todo1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::get_todo1()
+  } 
+  .property valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>
+          matchValue@25()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly::get_matchValue@25()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>
+          computation@25()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::get_computation@25()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>
+          todo2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::get_todo2()
+  } 
+  .property valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>
+          'matchValue@44-1'()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly::'get_matchValue@44-1'()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>
+          'computation@44-1'()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::'get_computation@44-1'()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly$fsx
+       extends [runtime]System.Object
+{
+  .field static assembly initonly class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> todo1@16
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly initonly valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> matchValue@25
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly initonly class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> computation@25
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly initonly class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> todo2@35
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly initonly valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'matchValue@44-1'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly initonly class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> 'computation@44-1'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  5
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 assembly/Foo::x
+    IL_0006:  ldc.i4.1
+    IL_0007:  volatile.
+    IL_0009:  stsfld     int32 assembly/Foo::init@4
+    IL_000e:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+    IL_0013:  ldsfld     class assembly/todo1@18 assembly/todo1@18::@_instance
+    IL_0018:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+    IL_001d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> '<StartupCode$assembly>'.$assembly$fsx::todo1@16
+    IL_0022:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::get_todo1()
+    IL_0027:  stsfld     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> '<StartupCode$assembly>'.$assembly$fsx::computation@25
+    IL_002c:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::get_computation@25()
+    IL_0031:  ldnull
+    IL_0032:  ldnull
+    IL_0033:  call       !!0 [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync::RunSynchronously<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<int32>,
+                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<valuetype [runtime]System.Threading.CancellationToken>)
+    IL_0038:  stsfld     valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> '<StartupCode$assembly>'.$assembly$fsx::matchValue@25
+    IL_003d:  ldsflda    valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> '<StartupCode$assembly>'.$assembly$fsx::matchValue@25
+    IL_0042:  call       instance int32 valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::get_Tag()
+    IL_0047:  ldc.i4.1
+    IL_0048:  bne.un.s   IL_004c
+
+    IL_004a:  br.s       IL_004e
+
+    IL_004c:  br.s       IL_005d
+
+    IL_004e:  ldsflda    valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> '<StartupCode$assembly>'.$assembly$fsx::matchValue@25
+    IL_0053:  call       instance !1 valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::get_ErrorValue()
+    IL_0058:  call       void [runtime]System.Environment::Exit(int32)
+    IL_005d:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+    IL_0062:  ldsfld     class assembly/todo2@37 assembly/todo2@37::@_instance
+    IL_0067:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+    IL_006c:  stsfld     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> '<StartupCode$assembly>'.$assembly$fsx::todo2@35
+    IL_0071:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::get_todo2()
+    IL_0076:  stsfld     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> '<StartupCode$assembly>'.$assembly$fsx::'computation@44-1'
+    IL_007b:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::'get_computation@44-1'()
+    IL_0080:  ldnull
+    IL_0081:  ldnull
+    IL_0082:  call       !!0 [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync::RunSynchronously<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<int32>,
+                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<valuetype [runtime]System.Threading.CancellationToken>)
+    IL_0087:  stsfld     valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> '<StartupCode$assembly>'.$assembly$fsx::'matchValue@44-1'
+    IL_008c:  ldsflda    valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> '<StartupCode$assembly>'.$assembly$fsx::'matchValue@44-1'
+    IL_0091:  call       instance int32 valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::get_Tag()
+    IL_0096:  ldc.i4.1
+    IL_0097:  bne.un.s   IL_009b
+
+    IL_0099:  br.s       IL_009d
+
+    IL_009b:  br.s       IL_00ac
+
+    IL_009d:  ldsflda    valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> '<StartupCode$assembly>'.$assembly$fsx::'matchValue@44-1'
+    IL_00a2:  call       instance !1 valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::get_ErrorValue()
+    IL_00a7:  call       void [runtime]System.Environment::Exit(int32)
+    IL_00ac:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.realInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.realInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..c6f995e96f1
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.realInternalSignatureOn.il.bsl
@@ -0,0 +1,598 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public Foo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field static assembly int32 x
+    .field static assembly int32 init@4
+    .method private specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ret
+    } 
+
+    .method public specialname static int32 get_X() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 assembly/Foo::init@4
+      IL_0007:  ldc.i4.1
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldsfld     int32 assembly/Foo::x
+      IL_0016:  ret
+    } 
+
+    .method public specialname static void set_X(int32 v) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  volatile.
+      IL_0002:  ldsfld     int32 assembly/Foo::init@4
+      IL_0007:  ldc.i4.1
+      IL_0008:  bge.s      IL_0011
+
+      IL_000a:  call       void [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::FailStaticInit()
+      IL_000f:  br.s       IL_0011
+
+      IL_0011:  ldarg.0
+      IL_0012:  stsfld     int32 assembly/Foo::x
+      IL_0017:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+      IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+      IL_000b:  pop
+      IL_000c:  ret
+    } 
+
+    .method assembly specialname static void staticInitialization@() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldc.i4.0
+      IL_0001:  stsfld     int32 assembly/Foo::x
+      IL_0006:  ldc.i4.1
+      IL_0007:  volatile.
+      IL_0009:  stsfld     int32 assembly/Foo::init@4
+      IL_000e:  ret
+    } 
+
+    .property int32 X()
+    {
+      .set void assembly/Foo::set_X(int32)
+      .get int32 assembly/Foo::get_X()
+    } 
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'todo1@20-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+  {
+    .field public valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'value'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'value') cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly/'todo1@20-1'::'value'
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> ctxt) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.0
+      IL_0002:  ldfld      valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly/'todo1@20-1'::'value'
+      IL_0007:  tail.
+      IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>::Success(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!0>,
+                                                                                                                                                                                                                                                                                !0)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'todo1@22-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+  {
+    .field public valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'value'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'value') cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly/'todo1@22-2'::'value'
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> ctxt) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.0
+      IL_0002:  ldfld      valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly/'todo1@22-2'::'value'
+      IL_0007:  tail.
+      IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>::Success(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!0>,
+                                                                                                                                                                                                                                                                                !0)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit todo1@18
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>>
+  {
+    .field static assembly initonly class assembly/todo1@18 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> V_0)
+      IL_0000:  ldc.i4.1
+      IL_0001:  call       void assembly/Foo::set_X(int32)
+      IL_0006:  call       int32 assembly/Foo::get_X()
+      IL_000b:  ldc.i4.1
+      IL_000c:  beq.s      IL_0023
+
+      IL_000e:  ldc.i4.1
+      IL_000f:  call       valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<!0,!1> valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::NewError(!1)
+      IL_0014:  stloc.0
+      IL_0015:  ldloc.0
+      IL_0016:  newobj     instance void assembly/'todo1@20-1'::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>)
+      IL_001b:  tail.
+      IL_001d:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+      IL_0022:  ret
+
+      IL_0023:  ldnull
+      IL_0024:  call       valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<!0,!1> valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::NewOk(!0)
+      IL_0029:  stloc.0
+      IL_002a:  ldloc.0
+      IL_002b:  newobj     instance void assembly/'todo1@22-2'::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>)
+      IL_0030:  tail.
+      IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+      IL_0037:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/todo1@18::.ctor()
+      IL_0005:  stsfld     class assembly/todo1@18 assembly/todo1@18::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'todo2@39-1'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+  {
+    .field public valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'value'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'value') cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly/'todo2@39-1'::'value'
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> ctxt) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.0
+      IL_0002:  ldfld      valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly/'todo2@39-1'::'value'
+      IL_0007:  tail.
+      IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>::Success(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!0>,
+                                                                                                                                                                                                                                                                                !0)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit 'todo2@41-2'
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>
+  {
+    .field public valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'value'
+    .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+    .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+    .method assembly specialname rtspecialname instance void  .ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'value') cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  ldarg.1
+      IL_0008:  stfld      valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly/'todo2@41-2'::'value'
+      IL_000d:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn Invoke(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> ctxt) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.1
+      IL_0001:  ldarg.0
+      IL_0002:  ldfld      valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly/'todo2@41-2'::'value'
+      IL_0007:  tail.
+      IL_0009:  call       class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>::Success(valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!0>,
+                                                                                                                                                                                                                                                                                !0)
+      IL_000e:  ret
+    } 
+
+  } 
+
+  .class auto ansi serializable sealed nested assembly beforefieldinit todo2@37
+         extends class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>>
+  {
+    .field static assembly initonly class assembly/todo2@37 @_instance
+    .method assembly specialname rtspecialname instance void  .ctor() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       instance void class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>>::.ctor()
+      IL_0006:  ret
+    } 
+
+    .method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> Invoke(class [FSharp.Core]Microsoft.FSharp.Core.Unit unitVar) cil managed
+    {
+      
+      .maxstack  6
+      .locals init (valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> V_0)
+      IL_0000:  ldc.i4.2
+      IL_0001:  call       void assembly/Foo::set_X(int32)
+      IL_0006:  call       int32 assembly/Foo::get_X()
+      IL_000b:  ldc.i4.2
+      IL_000c:  beq.s      IL_0023
+
+      IL_000e:  ldc.i4.2
+      IL_000f:  call       valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<!0,!1> valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::NewError(!1)
+      IL_0014:  stloc.0
+      IL_0015:  ldloc.0
+      IL_0016:  newobj     instance void assembly/'todo2@39-1'::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>)
+      IL_001b:  tail.
+      IL_001d:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+      IL_0022:  ret
+
+      IL_0023:  ldnull
+      IL_0024:  call       valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<!0,!1> valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::NewOk(!0)
+      IL_0029:  stloc.0
+      IL_002a:  ldloc.0
+      IL_002b:  newobj     instance void assembly/'todo2@41-2'::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>)
+      IL_0030:  tail.
+      IL_0032:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.AsyncPrimitives::MakeAsync<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<valuetype [FSharp.Core]Microsoft.FSharp.Control.AsyncActivation`1<!!0>,class [FSharp.Core]Microsoft.FSharp.Control.AsyncReturn>)
+      IL_0037:  ret
+    } 
+
+    .method private specialname rtspecialname static void  .cctor() cil managed
+    {
+      
+      .maxstack  10
+      IL_0000:  newobj     instance void assembly/todo2@37::.ctor()
+      IL_0005:  stsfld     class assembly/todo2@37 assembly/todo2@37::@_instance
+      IL_000a:  ret
+    } 
+
+  } 
+
+  .class abstract auto ansi sealed nested public Exts2
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .method public static void  Foo.X.Static(int32 v) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldc.i4.2
+      IL_0002:  mul
+      IL_0003:  call       void assembly/Foo::set_X(int32)
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .class abstract auto ansi sealed nested public Exts
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .method public static void  Foo.X.Static(int32 v) cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  call       void assembly/Foo::set_X(int32)
+      IL_0006:  ret
+    } 
+
+  } 
+
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> todo1@16
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> matchValue@25
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> computation@25
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> todo2@35
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'matchValue@44-1'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> 'computation@44-1'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> get_todo1() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::todo1@16
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> get_matchValue@25() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly::matchValue@25
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> get_computation@25() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::computation@25
+    IL_0005:  ret
+  } 
+
+  .method public specialname static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> get_todo2() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::todo2@35
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> 'get_matchValue@44-1'() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly::'matchValue@44-1'
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> 'get_computation@44-1'() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::'computation@44-1'
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  5
+    IL_0000:  call       void assembly/Foo::staticInitialization@()
+    IL_0005:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+    IL_000a:  ldsfld     class assembly/todo1@18 assembly/todo1@18::@_instance
+    IL_000f:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+    IL_0014:  stsfld     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::todo1@16
+    IL_0019:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::get_todo1()
+    IL_001e:  stsfld     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::computation@25
+    IL_0023:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::get_computation@25()
+    IL_0028:  ldnull
+    IL_0029:  ldnull
+    IL_002a:  call       !!0 [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync::RunSynchronously<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<int32>,
+                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<valuetype [runtime]System.Threading.CancellationToken>)
+    IL_002f:  stsfld     valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly::matchValue@25
+    IL_0034:  ldsflda    valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly::matchValue@25
+    IL_0039:  call       instance int32 valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::get_Tag()
+    IL_003e:  ldc.i4.1
+    IL_003f:  bne.un.s   IL_0043
+
+    IL_0041:  br.s       IL_0045
+
+    IL_0043:  br.s       IL_0054
+
+    IL_0045:  ldsflda    valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly::matchValue@25
+    IL_004a:  call       instance !1 valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::get_ErrorValue()
+    IL_004f:  call       void [runtime]System.Environment::Exit(int32)
+    IL_0054:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder [FSharp.Core]Microsoft.FSharp.Core.ExtraTopLevelOperators::get_DefaultAsyncBuilder()
+    IL_0059:  ldsfld     class assembly/todo2@37 assembly/todo2@37::@_instance
+    IL_005e:  callvirt   instance class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0> [FSharp.Core]Microsoft.FSharp.Control.FSharpAsyncBuilder::Delay<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>(class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>>)
+    IL_0063:  stsfld     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::todo2@35
+    IL_0068:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::get_todo2()
+    IL_006d:  stsfld     class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::'computation@44-1'
+    IL_0072:  call       class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::'get_computation@44-1'()
+    IL_0077:  ldnull
+    IL_0078:  ldnull
+    IL_0079:  call       !!0 [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync::RunSynchronously<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>(class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<!!0>,
+                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<int32>,
+                                                                                                                                                                                                                   class [FSharp.Core]Microsoft.FSharp.Core.FSharpOption`1<valuetype [runtime]System.Threading.CancellationToken>)
+    IL_007e:  stsfld     valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly::'matchValue@44-1'
+    IL_0083:  ldsflda    valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly::'matchValue@44-1'
+    IL_0088:  call       instance int32 valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::get_Tag()
+    IL_008d:  ldc.i4.1
+    IL_008e:  bne.un.s   IL_0092
+
+    IL_0090:  br.s       IL_0094
+
+    IL_0092:  br.s       IL_00a3
+
+    IL_0094:  ldsflda    valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly::'matchValue@44-1'
+    IL_0099:  call       instance !1 valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>::get_ErrorValue()
+    IL_009e:  call       void [runtime]System.Environment::Exit(int32)
+    IL_00a3:  ret
+  } 
+
+  .property class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>
+          todo1()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::get_todo1()
+  } 
+  .property valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>
+          matchValue@25()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly::get_matchValue@25()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>
+          computation@25()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::get_computation@25()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>
+          todo2()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::get_todo2()
+  } 
+  .property valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>
+          'matchValue@44-1'()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32> assembly::'get_matchValue@44-1'()
+  } 
+  .property class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>>
+          'computation@44-1'()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class [FSharp.Core]Microsoft.FSharp.Control.FSharpAsync`1<valuetype [FSharp.Core]Microsoft.FSharp.Core.FSharpResult`2<class [FSharp.Core]Microsoft.FSharp.Core.Unit,int32>> assembly::'get_computation@44-1'()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly$fsx
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.support.added.later.err.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.support.added.later.err.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.support.added.later.err.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.support.added.later.err.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.support.added.later.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.support.added.later.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.support.added.later.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithLastOpenedTypeExtensions.fsx.support.added.later.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithTypeExtension.fsx b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithTypeExtension.fsx
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithTypeExtension.fsx
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithTypeExtension.fsx
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithTypeExtension.fsx.err.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithTypeExtension.fsx.err.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithTypeExtension.fsx.err.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithTypeExtension.fsx.err.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithTypeExtension.fsx.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithTypeExtension.fsx.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithTypeExtension.fsx.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithTypeExtension.fsx.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithTypeExtension.fsx.realInternalSignatureOff.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithTypeExtension.fsx.realInternalSignatureOff.il.bsl
new file mode 100644
index 00000000000..8707d390da5
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithTypeExtension.fsx.realInternalSignatureOff.il.bsl
@@ -0,0 +1,221 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public Foo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly int32 X@
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldc.i4.0
+      IL_000a:  stfld      int32 assembly/Foo::X@
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_X() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/Foo::X@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname instance void  set_X(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 assembly/Foo::X@
+      IL_0007:  ret
+    } 
+
+    .property instance int32 X()
+    {
+      .set instance void assembly/Foo::set_X(int32)
+      .get instance int32 assembly/Foo::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public Exts
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .method public static class assembly/Foo 
+            Foo.X(class assembly/Foo f,
+                  int32 i) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 assembly/Foo::X@
+      IL_0007:  ldarg.0
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .method public specialname static class assembly/Foo get_f() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::f@11
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class assembly/Foo get_f@8() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::'f@8-1'
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class assembly/Foo 'get_f@8-1'() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::'f@8-2'
+    IL_0005:  ret
+  } 
+
+  .property class assembly/Foo
+          f()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::get_f()
+  } 
+  .property class assembly/Foo
+          f@8()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::get_f@8()
+  } 
+  .property class assembly/Foo
+          'f@8-1'()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::'get_f@8-1'()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly$fsx
+       extends [runtime]System.Object
+{
+  .field static assembly initonly class assembly/Foo f@11
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly initonly class assembly/Foo 'f@8-1'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly initonly class assembly/Foo 'f@8-2'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  4
+    IL_0000:  newobj     instance void assembly/Foo::.ctor()
+    IL_0005:  stsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::f@11
+    IL_000a:  call       class assembly/Foo assembly::get_f()
+    IL_000f:  ldc.i4.1
+    IL_0010:  stfld      int32 assembly/Foo::X@
+    IL_0015:  call       class assembly/Foo assembly::get_f()
+    IL_001a:  pop
+    IL_001b:  call       class assembly/Foo assembly::get_f()
+    IL_0020:  ldfld      int32 assembly/Foo::X@
+    IL_0025:  ldc.i4.1
+    IL_0026:  beq.s      IL_0030
+
+    IL_0028:  ldc.i4.1
+    IL_0029:  call       void [runtime]System.Environment::Exit(int32)
+    IL_002e:  br.s       IL_0030
+
+    IL_0030:  call       class assembly/Foo assembly::get_f()
+    IL_0035:  ldc.i4.1
+    IL_0036:  stfld      int32 assembly/Foo::X@
+    IL_003b:  call       class assembly/Foo assembly::get_f()
+    IL_0040:  stsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::'f@8-2'
+    IL_0045:  call       class assembly/Foo assembly::'get_f@8-1'()
+    IL_004a:  ldc.i4.2
+    IL_004b:  stfld      int32 assembly/Foo::X@
+    IL_0050:  call       class assembly/Foo assembly::'get_f@8-1'()
+    IL_0055:  stsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::'f@8-1'
+    IL_005a:  call       class assembly/Foo assembly::get_f@8()
+    IL_005f:  ldc.i4.3
+    IL_0060:  stfld      int32 assembly/Foo::X@
+    IL_0065:  call       class assembly/Foo assembly::get_f@8()
+    IL_006a:  pop
+    IL_006b:  call       class assembly/Foo assembly::get_f()
+    IL_0070:  ldfld      int32 assembly/Foo::X@
+    IL_0075:  ldc.i4.3
+    IL_0076:  beq.s      IL_0080
+
+    IL_0078:  ldc.i4.2
+    IL_0079:  call       void [runtime]System.Environment::Exit(int32)
+    IL_007e:  br.s       IL_0080
+
+    IL_0080:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithTypeExtension.fsx.realInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithTypeExtension.fsx.realInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..dbcbebee176
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithTypeExtension.fsx.realInternalSignatureOn.il.bsl
@@ -0,0 +1,240 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public Foo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly int32 X@
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldc.i4.0
+      IL_000a:  stfld      int32 assembly/Foo::X@
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_X() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/Foo::X@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname instance void  set_X(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 assembly/Foo::X@
+      IL_0007:  ret
+    } 
+
+    .property instance int32 X()
+    {
+      .set instance void assembly/Foo::set_X(int32)
+      .get instance int32 assembly/Foo::get_X()
+    } 
+  } 
+
+  .class abstract auto ansi sealed nested public Exts
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+    .method public static class assembly/Foo 
+            Foo.X(class assembly/Foo f,
+                  int32 i) cil managed
+    {
+      .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = ( 01 00 02 00 00 00 01 00 00 00 01 00 00 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 assembly/Foo::X@
+      IL_0007:  ldarg.0
+      IL_0008:  ret
+    } 
+
+  } 
+
+  .field static assembly class assembly/Foo f@11
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class assembly/Foo 'f@8-1'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class assembly/Foo 'f@8-2'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class assembly/Foo get_f() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo assembly::f@11
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class assembly/Foo get_f@8() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo assembly::'f@8-1'
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class assembly/Foo 'get_f@8-1'() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo assembly::'f@8-2'
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    IL_0000:  newobj     instance void assembly/Foo::.ctor()
+    IL_0005:  stsfld     class assembly/Foo assembly::f@11
+    IL_000a:  call       class assembly/Foo assembly::get_f()
+    IL_000f:  ldc.i4.1
+    IL_0010:  stfld      int32 assembly/Foo::X@
+    IL_0015:  call       class assembly/Foo assembly::get_f()
+    IL_001a:  pop
+    IL_001b:  call       class assembly/Foo assembly::get_f()
+    IL_0020:  ldfld      int32 assembly/Foo::X@
+    IL_0025:  ldc.i4.1
+    IL_0026:  beq.s      IL_0030
+
+    IL_0028:  ldc.i4.1
+    IL_0029:  call       void [runtime]System.Environment::Exit(int32)
+    IL_002e:  br.s       IL_0030
+
+    IL_0030:  call       class assembly/Foo assembly::get_f()
+    IL_0035:  ldc.i4.1
+    IL_0036:  stfld      int32 assembly/Foo::X@
+    IL_003b:  call       class assembly/Foo assembly::get_f()
+    IL_0040:  stsfld     class assembly/Foo assembly::'f@8-2'
+    IL_0045:  call       class assembly/Foo assembly::'get_f@8-1'()
+    IL_004a:  ldc.i4.2
+    IL_004b:  stfld      int32 assembly/Foo::X@
+    IL_0050:  call       class assembly/Foo assembly::'get_f@8-1'()
+    IL_0055:  stsfld     class assembly/Foo assembly::'f@8-1'
+    IL_005a:  call       class assembly/Foo assembly::get_f@8()
+    IL_005f:  ldc.i4.3
+    IL_0060:  stfld      int32 assembly/Foo::X@
+    IL_0065:  call       class assembly/Foo assembly::get_f@8()
+    IL_006a:  pop
+    IL_006b:  call       class assembly/Foo assembly::get_f()
+    IL_0070:  ldfld      int32 assembly/Foo::X@
+    IL_0075:  ldc.i4.3
+    IL_0076:  beq.s      IL_0080
+
+    IL_0078:  ldc.i4.2
+    IL_0079:  call       void [runtime]System.Environment::Exit(int32)
+    IL_007e:  br.s       IL_0080
+
+    IL_0080:  ret
+  } 
+
+  .property class assembly/Foo
+          f()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::get_f()
+  } 
+  .property class assembly/Foo
+          f@8()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::get_f@8()
+  } 
+  .property class assembly/Foo
+          'f@8-1'()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::'get_f@8-1'()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly$fsx
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithTypeExtension.fsx.support.added.later.err.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithTypeExtension.fsx.support.added.later.err.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithTypeExtension.fsx.support.added.later.err.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithTypeExtension.fsx.support.added.later.err.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithTypeExtension.fsx.support.added.later.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithTypeExtension.fsx.support.added.later.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowWithTypeExtension.fsx.support.added.later.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowWithTypeExtension.fsx.support.added.later.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.err.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.err.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.err.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.err.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.il.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.realInternalSignatureOff.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.realInternalSignatureOff.il.bsl
new file mode 100644
index 00000000000..6d38176836d
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.realInternalSignatureOff.il.bsl
@@ -0,0 +1,246 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public Foo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly int32 X@
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldc.i4.0
+      IL_000a:  stfld      int32 assembly/Foo::X@
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_X() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/Foo::X@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname instance void  set_X(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 assembly/Foo::X@
+      IL_0007:  ret
+    } 
+
+    .property instance int32 X()
+    {
+      .set instance void assembly/Foo::set_X(int32)
+      .get instance int32 assembly/Foo::get_X()
+    } 
+  } 
+
+  .class auto ansi serializable nested public FooExt
+         extends [runtime]System.Object
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.ExtensionAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public static class assembly/Foo 
+            X(class assembly/Foo f,
+              int32 i) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.ExtensionAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 assembly/Foo::X@
+      IL_0007:  ldarg.0
+      IL_0008:  ret
+    } 
+
+    .method public static class assembly/Foo 
+            X(class assembly/Foo f,
+              string i) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.ExtensionAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.0
+      IL_0002:  ldfld      int32 assembly/Foo::X@
+      IL_0007:  stloc.0
+      IL_0008:  ldloca.s   V_0
+      IL_000a:  constrained. [runtime]System.Int32
+      IL_0010:  callvirt   instance string [runtime]System.Object::ToString()
+      IL_0015:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_001a:  ldarg.1
+      IL_001b:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0020:  add
+      IL_0021:  stfld      int32 assembly/Foo::X@
+      IL_0026:  ldarg.0
+      IL_0027:  ret
+    } 
+
+  } 
+
+  .method public specialname static class assembly/Foo get_f() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::f@17
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class assembly/Foo get_f@10() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::'f@10-1'
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class assembly/Foo 'get_f@10-1'() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::'f@10-2'
+    IL_0005:  ret
+  } 
+
+  .property class assembly/Foo
+          f()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::get_f()
+  } 
+  .property class assembly/Foo
+          f@10()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::get_f@10()
+  } 
+  .property class assembly/Foo
+          'f@10-1'()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::'get_f@10-1'()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly$fsx
+       extends [runtime]System.Object
+{
+  .field static assembly initonly class assembly/Foo f@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly initonly class assembly/Foo 'f@10-1'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly initonly class assembly/Foo 'f@10-2'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  4
+    IL_0000:  newobj     instance void assembly/Foo::.ctor()
+    IL_0005:  stsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::f@17
+    IL_000a:  call       class assembly/Foo assembly::get_f()
+    IL_000f:  ldc.i4.1
+    IL_0010:  stfld      int32 assembly/Foo::X@
+    IL_0015:  call       class assembly/Foo assembly::get_f()
+    IL_001a:  pop
+    IL_001b:  call       class assembly/Foo assembly::get_f()
+    IL_0020:  ldfld      int32 assembly/Foo::X@
+    IL_0025:  ldc.i4.1
+    IL_0026:  beq.s      IL_0030
+
+    IL_0028:  ldc.i4.1
+    IL_0029:  call       void [runtime]System.Environment::Exit(int32)
+    IL_002e:  br.s       IL_0030
+
+    IL_0030:  call       class assembly/Foo assembly::get_f()
+    IL_0035:  ldc.i4.1
+    IL_0036:  stfld      int32 assembly/Foo::X@
+    IL_003b:  call       class assembly/Foo assembly::get_f()
+    IL_0040:  stsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::'f@10-2'
+    IL_0045:  call       class assembly/Foo assembly::'get_f@10-1'()
+    IL_004a:  ldc.i4.2
+    IL_004b:  stfld      int32 assembly/Foo::X@
+    IL_0050:  call       class assembly/Foo assembly::'get_f@10-1'()
+    IL_0055:  stsfld     class assembly/Foo '<StartupCode$assembly>'.$assembly$fsx::'f@10-1'
+    IL_005a:  call       class assembly/Foo assembly::get_f@10()
+    IL_005f:  ldc.i4.3
+    IL_0060:  stfld      int32 assembly/Foo::X@
+    IL_0065:  call       class assembly/Foo assembly::get_f@10()
+    IL_006a:  pop
+    IL_006b:  call       class assembly/Foo assembly::get_f()
+    IL_0070:  ldfld      int32 assembly/Foo::X@
+    IL_0075:  ldc.i4.3
+    IL_0076:  beq.s      IL_0080
+
+    IL_0078:  ldc.i4.2
+    IL_0079:  call       void [runtime]System.Environment::Exit(int32)
+    IL_007e:  br.s       IL_0080
+
+    IL_0080:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.realInternalSignatureOn.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.realInternalSignatureOn.il.bsl
new file mode 100644
index 00000000000..c696c9e43d0
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.realInternalSignatureOn.il.bsl
@@ -0,0 +1,265 @@
+
+
+
+
+
+.assembly extern runtime { }
+.assembly extern FSharp.Core { }
+.assembly assembly
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute::.ctor(int32,
+                                                                                                      int32,
+                                                                                                      int32) = ( 01 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 ) 
+  .hash algorithm 0x00008004
+  .ver 0:0:0:0
+}
+.mresource public FSharpSignatureData.assembly
+{
+  
+  
+}
+.mresource public FSharpOptimizationData.assembly
+{
+  
+  
+}
+.module assembly.dll
+
+.imagebase {value}
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       
+.corflags 0x00000001    
+
+
+
+
+
+.class public abstract auto ansi sealed assembly
+       extends [runtime]System.Object
+{
+  .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 07 00 00 00 00 00 ) 
+  .class auto ansi serializable nested public Foo
+         extends [runtime]System.Object
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .field assembly int32 X@
+    .method public specialname rtspecialname instance void  .ctor() cil managed
+    {
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  callvirt   instance void [runtime]System.Object::.ctor()
+      IL_0006:  ldarg.0
+      IL_0007:  pop
+      IL_0008:  ldarg.0
+      IL_0009:  ldc.i4.0
+      IL_000a:  stfld      int32 assembly/Foo::X@
+      IL_000f:  ret
+    } 
+
+    .method public hidebysig specialname instance int32  get_X() cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldfld      int32 assembly/Foo::X@
+      IL_0006:  ret
+    } 
+
+    .method public hidebysig specialname instance void  set_X(int32 v) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+      .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 assembly/Foo::X@
+      IL_0007:  ret
+    } 
+
+    .property instance int32 X()
+    {
+      .set instance void assembly/Foo::set_X(int32)
+      .get instance int32 assembly/Foo::get_X()
+    } 
+  } 
+
+  .class auto ansi serializable nested public FooExt
+         extends [runtime]System.Object
+  {
+    .custom instance void [runtime]System.Runtime.CompilerServices.ExtensionAttribute::.ctor() = ( 01 00 00 00 ) 
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 03 00 00 00 00 00 ) 
+    .method public static class assembly/Foo 
+            X(class assembly/Foo f,
+              int32 i) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.ExtensionAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.1
+      IL_0002:  stfld      int32 assembly/Foo::X@
+      IL_0007:  ldarg.0
+      IL_0008:  ret
+    } 
+
+    .method public static class assembly/Foo 
+            X(class assembly/Foo f,
+              string i) cil managed
+    {
+      .custom instance void [runtime]System.Runtime.CompilerServices.ExtensionAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  5
+      .locals init (int32 V_0)
+      IL_0000:  ldarg.0
+      IL_0001:  ldarg.0
+      IL_0002:  ldfld      int32 assembly/Foo::X@
+      IL_0007:  stloc.0
+      IL_0008:  ldloca.s   V_0
+      IL_000a:  constrained. [runtime]System.Int32
+      IL_0010:  callvirt   instance string [runtime]System.Object::ToString()
+      IL_0015:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_001a:  ldarg.1
+      IL_001b:  callvirt   instance int32 [runtime]System.String::get_Length()
+      IL_0020:  add
+      IL_0021:  stfld      int32 assembly/Foo::X@
+      IL_0026:  ldarg.0
+      IL_0027:  ret
+    } 
+
+  } 
+
+  .field static assembly class assembly/Foo f@17
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class assembly/Foo 'f@10-1'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .field static assembly class assembly/Foo 'f@10-2'
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .method public specialname static class assembly/Foo get_f() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo assembly::f@17
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class assembly/Foo get_f@10() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo assembly::'f@10-1'
+    IL_0005:  ret
+  } 
+
+  .method assembly specialname static class assembly/Foo 'get_f@10-1'() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldsfld     class assembly/Foo assembly::'f@10-2'
+    IL_0005:  ret
+  } 
+
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  ldc.i4.0
+    IL_0001:  stsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+    IL_0006:  ldsfld     int32 '<StartupCode$assembly>'.$assembly$fsx::init@
+    IL_000b:  pop
+    IL_000c:  ret
+  } 
+
+  .method assembly specialname static void staticInitialization@() cil managed
+  {
+    
+    .maxstack  4
+    IL_0000:  newobj     instance void assembly/Foo::.ctor()
+    IL_0005:  stsfld     class assembly/Foo assembly::f@17
+    IL_000a:  call       class assembly/Foo assembly::get_f()
+    IL_000f:  ldc.i4.1
+    IL_0010:  stfld      int32 assembly/Foo::X@
+    IL_0015:  call       class assembly/Foo assembly::get_f()
+    IL_001a:  pop
+    IL_001b:  call       class assembly/Foo assembly::get_f()
+    IL_0020:  ldfld      int32 assembly/Foo::X@
+    IL_0025:  ldc.i4.1
+    IL_0026:  beq.s      IL_0030
+
+    IL_0028:  ldc.i4.1
+    IL_0029:  call       void [runtime]System.Environment::Exit(int32)
+    IL_002e:  br.s       IL_0030
+
+    IL_0030:  call       class assembly/Foo assembly::get_f()
+    IL_0035:  ldc.i4.1
+    IL_0036:  stfld      int32 assembly/Foo::X@
+    IL_003b:  call       class assembly/Foo assembly::get_f()
+    IL_0040:  stsfld     class assembly/Foo assembly::'f@10-2'
+    IL_0045:  call       class assembly/Foo assembly::'get_f@10-1'()
+    IL_004a:  ldc.i4.2
+    IL_004b:  stfld      int32 assembly/Foo::X@
+    IL_0050:  call       class assembly/Foo assembly::'get_f@10-1'()
+    IL_0055:  stsfld     class assembly/Foo assembly::'f@10-1'
+    IL_005a:  call       class assembly/Foo assembly::get_f@10()
+    IL_005f:  ldc.i4.3
+    IL_0060:  stfld      int32 assembly/Foo::X@
+    IL_0065:  call       class assembly/Foo assembly::get_f@10()
+    IL_006a:  pop
+    IL_006b:  call       class assembly/Foo assembly::get_f()
+    IL_0070:  ldfld      int32 assembly/Foo::X@
+    IL_0075:  ldc.i4.3
+    IL_0076:  beq.s      IL_0080
+
+    IL_0078:  ldc.i4.2
+    IL_0079:  call       void [runtime]System.Environment::Exit(int32)
+    IL_007e:  br.s       IL_0080
+
+    IL_0080:  ret
+  } 
+
+  .property class assembly/Foo
+          f()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::get_f()
+  } 
+  .property class assembly/Foo
+          f@10()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::get_f@10()
+  } 
+  .property class assembly/Foo
+          'f@10-1'()
+  {
+    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationMappingAttribute::.ctor(valuetype [FSharp.Core]Microsoft.FSharp.Core.SourceConstructFlags) = ( 01 00 09 00 00 00 00 00 ) 
+    .get class assembly/Foo assembly::'get_f@10-1'()
+  } 
+} 
+
+.class private abstract auto ansi sealed '<StartupCode$assembly>'.$assembly$fsx
+       extends [runtime]System.Object
+{
+  .field static assembly int32 init@
+  .custom instance void [runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [runtime]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) 
+  .custom instance void [runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
+  .custom instance void [runtime]System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() = ( 01 00 00 00 ) 
+  .method private specialname rtspecialname static void  .cctor() cil managed
+  {
+    
+    .maxstack  8
+    IL_0000:  call       void assembly::staticInitialization@()
+    IL_0005:  ret
+  } 
+
+} 
+
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.support.added.later.err.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.support.added.later.err.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.support.added.later.err.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.support.added.later.err.bsl
diff --git a/tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.support.added.later.il.bsl b/tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.support.added.later.il.bsl
similarity index 100%
rename from tests/FSharp.Compiler.ComponentTests/TypeChecks/TypeExtensions/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.support.added.later.il.bsl
rename to tests/FSharp.Compiler.ComponentTests/TypeChecks/Shadowing/ShadowingAndStillOkWithChainedCalls.fsx.support.added.later.il.bsl
diff --git a/tests/FSharp.Compiler.Service.Tests/expected-help-output.bsl b/tests/FSharp.Compiler.Service.Tests/expected-help-output.bsl
index bd71cfb26da..8f80673a9ba 100644
--- a/tests/FSharp.Compiler.Service.Tests/expected-help-output.bsl
+++ b/tests/FSharp.Compiler.Service.Tests/expected-help-output.bsl
@@ -91,6 +91,9 @@
 --deterministic[+|-]                     Produce a deterministic assembly
                                          (including module version GUID and
                                          timestamp)
+--realsig[+|-]                           Generate assembly with IL visibility
+                                         that matches the source code
+                                         visibility
 --pathmap:<path=sourcePath;...>          Maps physical paths to source path
                                          names output by the compiler
 --crossoptimize[+|-]                     Enable or disable cross-module
diff --git a/tests/FSharp.Test.Utilities/Compiler.fs b/tests/FSharp.Test.Utilities/Compiler.fs
index 0f79fbcbad8..1cbf3a3aade 100644
--- a/tests/FSharp.Test.Utilities/Compiler.fs
+++ b/tests/FSharp.Test.Utilities/Compiler.fs
@@ -207,7 +207,7 @@ module rec Compiler =
         | Arm = 5
         | Arm64 = 6
 
-    let public defaultOptions : string list = []
+    let public defaultOptions : string list = ["--realsig+"]
 
     let normalizePathSeparator (text:string) = text.Replace(@"\", "/")
 
@@ -588,6 +588,16 @@ module rec Compiler =
         | CS x -> CS { x with OutputType = outputType }
         | _ -> failwith "TODO: Implement where applicable."
 
+    let withRealInternalSignatureOff (cUnit: CompilationUnit) : CompilationUnit =
+        match cUnit with
+        | FS fs -> FS { fs with Options = fs.Options @ ["--realsig-"] }
+        | _ -> failwith "withRealInternalSignatureOff only supported by f#"
+
+    let withRealInternalSignatureOn (cUnit: CompilationUnit) : CompilationUnit =
+        match cUnit with
+        | FS fs -> FS { fs with Options = fs.Options @ ["--realsig+"] }
+        | _ -> failwith "withRealInternalSignatureOn only supported by f#"
+
     let asExe (cUnit: CompilationUnit) : CompilationUnit =
         withOutputType CompileOutput.Exe cUnit
 
@@ -1436,7 +1446,7 @@ Actual:
         let private getErrorInfo (info: ErrorInfo) : string =
             sprintf "%A %A" info.Error info.Message
 
-        let inline private assertErrorsLength (source: ErrorInfo list) (expected: 'a list) : unit =
+        let private assertErrorsLength (source: ErrorInfo list) (expected: 'a list) : unit =
             if (List.length source) <> (List.length expected) then
                 failwith (sprintf "Expected list of issues differ from compilation result:\nExpected:\n %A\nActual:\n %A" expected (List.map getErrorInfo source))
             ()
diff --git a/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Benchmarks.fs b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Benchmarks.fs
index a081437e1f0..cce09739135 100644
--- a/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Benchmarks.fs
+++ b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Benchmarks.fs
@@ -1,11 +1,11 @@
-namespace TaskPerf
+namespace MicroPerf
 
 open BenchmarkDotNet.Running
 
-module Main = 
+module Main =
 
     [<EntryPoint>]
-    let main _ = 
+    let main args = 
         printfn "Running benchmarks..."
-        let _ = BenchmarkRunner.Run<Collections.CollectionsBenchmark>()
-        0  
+        BenchmarkSwitcher.FromAssembly(typeof<Equality.FSharpCoreFunctions>.Assembly).Run(args) |> ignore
+        0
diff --git a/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/Arrays.fs b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/Arrays.fs
new file mode 100644
index 00000000000..742385d7720
--- /dev/null
+++ b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/Arrays.fs
@@ -0,0 +1,23 @@
+namespace Equality
+
+open BenchmarkDotNet.Attributes
+
+type Arrays() =
+
+    let numbers = Array.init 1000 id
+
+    [<Benchmark>]
+    member _.Int32() =
+        numbers |> Array.countBy  (fun n -> [| n % 7 |])
+
+    [<Benchmark>]
+    member _.Int64() =
+        numbers |> Array.countBy  (fun n -> [| int64 (n % 7) |])
+
+    [<Benchmark>]
+    member _.Byte() =
+        numbers |> Array.countBy  (fun n -> [| byte (n % 7) |])
+
+    [<Benchmark>]
+    member _.Obj() =
+        numbers |> Array.countBy  (fun n -> [| box (n % 7) |])
diff --git a/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/BasicTypes.fs b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/BasicTypes.fs
new file mode 100644
index 00000000000..219284fe732
--- /dev/null
+++ b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/BasicTypes.fs
@@ -0,0 +1,63 @@
+namespace Equality
+
+open BenchmarkDotNet.Attributes
+
+[<MemoryDiagnoser>]
+type BasicTypes() =
+
+    let bools = Array.init 1000 (fun n -> n % 2 = 0)
+    let sbytes = Array.init 1000 sbyte
+    let bytes = Array.init 1000 byte
+    let int16s = Array.init 1000 int16
+    let uint16s = Array.init 1000 uint16
+    let int32s = Array.init 1000 id
+    let uint32s = Array.init 1000 uint32
+    let int64s = Array.init 1000 int64
+    let uint64s = Array.init 1000 uint64
+    let intptrs = Array.init 1000 nativeint
+    let uintptrs = Array.init 1000 unativeint
+    let chars = Array.init 1000 char
+    let strings = Array.init 1000 string
+    let decimals = Array.init 1000 decimal
+
+    [<Benchmark>]
+    member _.Bool() = bools |> Array.distinct
+
+    [<Benchmark>]
+    member _.SByte() = sbytes |> Array.distinct
+
+    [<Benchmark>]
+    member _.Byte() = bytes |> Array.distinct
+
+    [<Benchmark>]
+    member _.Int16() = int16s |> Array.distinct
+
+    [<Benchmark>]
+    member _.UInt16() = uint16s |> Array.distinct
+    
+    [<Benchmark>]
+    member _.Int32() = int32s |> Array.distinct
+
+    [<Benchmark>]
+    member _.UInt32() = uint32s |> Array.distinct
+
+    [<Benchmark>]
+    member _.Int64() = int64s |> Array.distinct
+
+    [<Benchmark>]
+    member _.UInt64() = uint64s |> Array.distinct
+
+    [<Benchmark>]
+    member _.IntPtr() = intptrs |> Array.distinct
+
+    [<Benchmark>]
+    member _.UIntPtr() = uintptrs |> Array.distinct
+
+    [<Benchmark>]
+    member _.Char() = chars |> Array.distinct
+
+    [<Benchmark>]
+    member _.String() = strings |> Array.distinct
+
+    [<Benchmark>]
+    member _.Decimal() = decimals |> Array.distinct
diff --git a/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/FSharpCoreFunctions.fs b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/FSharpCoreFunctions.fs
new file mode 100644
index 00000000000..7b26d287ab9
--- /dev/null
+++ b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/FSharpCoreFunctions.fs
@@ -0,0 +1,102 @@
+namespace Equality
+
+open BenchmarkDotNet.Attributes
+
+[<Struct>]
+type SomeStruct =
+    val A : int
+    new a = { A = a }
+
+type FSharpCoreFunctions() =
+
+    let array = Array.init 1000 id
+    let list = List.init 1000 id
+    let seq = Seq.init 1000 id
+
+    [<Benchmark>]
+    member _.ArrayCountBy() =
+        array
+        |> Array.countBy (fun n -> SomeStruct(n % 7))
+
+    [<Benchmark>]
+    member _.ArrayGroupBy() =
+        array
+        |> Array.groupBy (fun n -> SomeStruct(n % 7))
+
+    [<Benchmark>]
+    member _.ArrayDistinct() =
+        array
+        |> Array.map (fun n -> SomeStruct(n % 7))
+        |> Array.distinct
+
+    [<Benchmark>]
+    member _.ArrayDistinctBy() =
+        array
+        |> Array.distinctBy (fun n -> SomeStruct(n % 7))
+
+    [<Benchmark>]
+    member _.ArrayExcept() =
+        array
+        |> Array.map SomeStruct
+        |> Array.except ([| SomeStruct 42 |])
+
+    [<Benchmark>]
+    member _.ListCountBy() =
+        list
+        |> List.countBy (fun n -> SomeStruct(n % 7))
+
+    [<Benchmark>]
+    member _.ListGroupBy() =
+        list
+        |> List.groupBy (fun n -> SomeStruct(n % 7))
+
+    [<Benchmark>]
+    member _.ListDistinct() =
+        list
+        |> List.map (fun n -> SomeStruct(n % 7))
+        |> List.distinct
+
+    [<Benchmark>]
+    member _.ListDistinctBy() =
+        list
+        |> List.distinctBy (fun n -> SomeStruct(n % 7))
+
+    [<Benchmark>]
+    member _.ListExcept() =
+        List.init 1000 id
+        |> List.map SomeStruct
+        |> List.except ([| SomeStruct 42 |])
+
+    [<Benchmark>]
+    member _.SeqCountBy() =
+        seq
+        |> Seq.countBy (fun n -> SomeStruct(n % 7))
+        |> Seq.last
+
+    [<Benchmark>]
+    member _.SeqGroupBy() =
+        seq
+        |> Seq.groupBy (fun n -> SomeStruct(n % 7))
+        |> Seq.last
+
+    [<Benchmark>]
+    member _.SeqDistinct() =
+        seq
+        |> Seq.map (fun n -> SomeStruct(n % 7))
+        |> Seq.distinct
+        |> Seq.last
+
+    [<Benchmark>]
+    member _.SeqDistinctBy() =
+        seq
+        |> Seq.distinctBy (fun n -> SomeStruct(n % 7))
+        |> Seq.last
+
+    [<Benchmark>]
+    member _.SeqExcept() =
+        seq
+        |> Seq.map SomeStruct
+        |> Seq.except ([| SomeStruct 42 |])
+        |> Seq.last
+
+
diff --git a/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/Floats.fs b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/Floats.fs
new file mode 100644
index 00000000000..22234e0da5e
--- /dev/null
+++ b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/Floats.fs
@@ -0,0 +1,20 @@
+namespace Equality
+
+open BenchmarkDotNet.Attributes
+
+[<MemoryDiagnoser>]
+type Floats() =
+
+    let numbers = Array.init 1000 (fun id -> id % 7)
+
+    [<Benchmark>]
+    member _.FloatER() = numbers |> Array.groupBy float
+
+    [<Benchmark>]
+    member _.Float32ER() = numbers |> Array.groupBy float32
+
+    [<Benchmark>]
+    member _.FloatPER() = numbers |> Array.Parallel.groupBy float
+
+    [<Benchmark>]
+    member _.Float32PER() = numbers |> Array.Parallel.groupBy float32
\ No newline at end of file
diff --git a/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/Misc.fs b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/Misc.fs
new file mode 100644
index 00000000000..fa7c445c620
--- /dev/null
+++ b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/Misc.fs
@@ -0,0 +1,78 @@
+namespace Equality
+
+open BenchmarkDotNet.Attributes
+
+open System
+
+[<Struct>]
+type BigStruct = 
+    val A : int64
+    val B : int64
+    new (a, b) = { A = a; B = b }
+
+[<Struct>]
+type Container<'a> =
+    val Item : 'a
+    new i = { Item = i }
+
+type RandomRecord = { 
+    Field1 : int
+    Field2 : string
+    Field3 : byte 
+}
+
+[<Struct>]
+type RandomRecordStruct = { 
+    Field1S : int
+    Field2S : string
+    Field3S : byte 
+}
+
+type RandomGeneric<'a> = RandomGeneric of 'a * 'a
+
+[<MemoryDiagnoser>]
+type Misc() =
+
+    let createBigStruct() = 
+        let n = Random().NextInt64()
+        Container (BigStruct (n, n))
+
+    [<Benchmark>]
+    member _.BigStruct() =
+        let set = Set.empty
+        for _ = 0 to 200000 do
+            set.Add (createBigStruct ()) |> ignore
+
+    [<Benchmark>]
+    member _.Record() =
+        let array = Array.init 1000 id
+        array |> Array.countBy (fun n -> { 
+            Field1 = n
+            Field2 = string n
+            Field3 = byte n 
+        })
+    
+    [<Benchmark>]
+    member _.RecordStruct() =
+        let array = Array.init 1000 id
+        array |> Array.countBy (fun n -> { 
+            Field1S = n
+            Field2S = string n
+            Field3S = byte n 
+        })
+
+    // BDN can't work with F# anon records yet
+    // https://github.com/dotnet/BenchmarkDotNet/issues/2530
+    // [<Benchmark>]
+    member _.AnonymousRecord() =
+        let array = Array.init 1000 id
+        array |> Array.countBy (fun n -> {| 
+            Field1A = n
+            Field2A = string n
+            Field3A = byte n 
+        |})
+
+    [<Benchmark>]
+    member _.GenericUnion() =
+        let array = Array.init 1000 id
+        array |> Array.countBy (fun n -> RandomGeneric(n, n))
diff --git a/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/OptionsAndCo.fs b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/OptionsAndCo.fs
new file mode 100644
index 00000000000..a31f53e3367
--- /dev/null
+++ b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/OptionsAndCo.fs
@@ -0,0 +1,45 @@
+namespace Equality
+
+open System
+open BenchmarkDotNet.Attributes
+
+[<MemoryDiagnoser>]
+type OptionsAndCo() =
+
+    let numbers = Array.init 1000 id
+
+    let createOption x = 
+        match x with
+        | x when x % 2 = 0 -> Some x
+        | _ -> None
+
+    let createValueOption x = 
+        match x with
+        | x when x % 2 = 0 -> ValueSome x
+        | _ -> ValueNone
+
+    let createResult x = 
+        match x with
+        | x when x % 2 = 0 -> Ok x
+        | x -> Error x
+
+    let createNullable x = 
+        match x with
+        | x when x % 2 = 0 -> Nullable x
+        | _ -> Nullable 42
+
+    [<Benchmark>]
+    member _.Option() = 
+        numbers |> Array.countBy createOption
+
+    [<Benchmark>]
+    member _.ValueOption() = 
+        numbers |> Array.countBy createValueOption
+
+    [<Benchmark>]
+    member _.Result() = 
+        numbers |> Array.countBy createResult
+
+    [<Benchmark>]
+    member _.Nullable() = 
+        numbers |> Array.countBy createNullable
diff --git a/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/Structs.fs b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/Structs.fs
new file mode 100644
index 00000000000..51f6f1689aa
--- /dev/null
+++ b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/Structs.fs
@@ -0,0 +1,39 @@
+namespace Equality
+
+open BenchmarkDotNet.Attributes
+
+[<MemoryDiagnoser>]
+type Structs() =
+
+    let numbers = Array.init 1000 id
+
+    let createStruct3 (x: int) = struct (x, x, x)
+    let createStruct4 (x: int) = struct (x, x, x, x)
+    let createStruct5 (x: int) = struct (x, x, x, x, x)
+    let createStruct6 (x: int) = struct (x, x, x, x, x, x)
+    let createStruct7 (x: int) = struct (x, x, x, x, x, x, x)
+    let createStruct8 (x: int) = struct (x, x, x, x, x, x, x, x)
+
+    [<Benchmark(Baseline = true)>]
+    member _.Struct3() =
+        numbers |> Array.countBy (fun n -> createStruct3 n)
+
+    [<Benchmark>]
+    member _.Struct4() =
+        numbers |> Array.countBy (fun n -> createStruct4 n)
+
+    [<Benchmark>]
+    member _.Struct5() =
+        numbers |> Array.countBy (fun n -> createStruct5 n)
+
+    [<Benchmark>]
+    member _.Struct6() =
+        numbers |> Array.countBy (fun n -> createStruct6 n)
+
+    [<Benchmark>]
+    member _.Struct7() =
+        numbers |> Array.countBy (fun n -> createStruct7 n)
+
+    [<Benchmark>]
+    member _.Struct8() =
+        numbers |> Array.countBy (fun n -> createStruct8 n)
\ No newline at end of file
diff --git a/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/Tuples.fs b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/Tuples.fs
new file mode 100644
index 00000000000..49b0dcd428c
--- /dev/null
+++ b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/Tuples.fs
@@ -0,0 +1,67 @@
+namespace Equality
+
+open BenchmarkDotNet.Attributes
+
+type SmallNonGenericTuple = SmallNonGenericTuple of int * string
+
+type SmallGenericTuple<'a> = SmallGenericTuple of int * 'a
+
+type BigNonGenericTuple = BigNonGenericTuple of int * string * byte * int * string * byte
+
+type BigGenericTuple<'a> = BigGenericTuple of int * 'a * byte * int * 'a * byte
+
+[<Struct>]
+type SmallNonGenericTupleStruct = SmallNonGenericTupleStruct of int * string
+
+[<Struct>]
+type SmallGenericTupleStruct<'a> = SmallGenericTupleStruct of int * 'a
+
+[<Struct>]
+type BigNonGenericTupleStruct = BigNonGenericTupleStruct of int * string * byte * int * string * byte
+
+[<Struct>]
+type BigGenericTupleStruct<'a> = BigGenericTupleStruct of int * 'a * byte * int * 'a * byte
+
+type ReferenceTuples() =
+
+    let numbers = Array.init 1000 id
+
+    [<Benchmark>]
+    member _.SmallNonGenericTuple() =
+        numbers
+        |> Array.countBy (fun n -> SmallNonGenericTuple(n, string n))
+
+    [<Benchmark>]
+    member _.SmallGenericTuple() =
+        numbers
+        |> Array.countBy (fun n -> SmallGenericTuple(n, string n))
+
+    [<Benchmark>]
+    member _.BigNonGenericTuple() =
+        numbers
+        |> Array.countBy (fun n -> BigNonGenericTuple(n, string n, byte n, n, string n, byte n))
+
+    [<Benchmark>]
+    member _.BigGenericTuple() =
+        numbers
+        |> Array.countBy (fun n -> BigGenericTuple(n, string n, byte n, n, string n, byte n))
+
+    [<Benchmark>]
+    member _.SmallNonGenericTupleStruct() =
+        numbers
+        |> Array.countBy (fun n -> SmallNonGenericTupleStruct(n, string n))
+
+    [<Benchmark>]
+    member _.SmallGenericTupleStruct() =
+        numbers
+        |> Array.countBy (fun n -> SmallGenericTupleStruct(n, string n))
+
+    [<Benchmark>]
+    member _.BigNonGenericTupleStruct() =
+        numbers
+        |> Array.countBy (fun n -> BigNonGenericTupleStruct(n, string n, byte n, n, string n, byte n))
+
+    [<Benchmark>]
+    member _.BigGenericTupleStruct() =
+        numbers
+        |> Array.countBy (fun n -> BigGenericTupleStruct(n, string n, byte n, n, string n, byte n))
diff --git a/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/ValueTypes.fs b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/ValueTypes.fs
new file mode 100644
index 00000000000..5e48a1c6a91
--- /dev/null
+++ b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/Equality/ValueTypes.fs
@@ -0,0 +1,39 @@
+namespace Equality
+
+open System
+open BenchmarkDotNet.Attributes
+
+type SomeEnum = 
+    | Case0 = 0
+    | Case1 = 1
+    | Case2 = 2
+
+[<MemoryDiagnoser>]
+type ValueTypes() =
+
+    let numbers = Array.init 1000 id
+    let now = DateTimeOffset.Now
+
+    let createFSharpStruct (x: int) = 
+        struct (x % 7, x % 7)
+
+    let createFSharpEnum (x: int) =
+        enum<SomeEnum>(x % 3)
+
+    let createCSharpStruct (x: int) = 
+        now.AddMinutes x
+
+    let createCSharpEnum (x: int) =
+        enum<System.DayOfWeek>(x % 7)
+
+    [<Benchmark>]
+    member _.FSharpStruct() = numbers |> Array.countBy createFSharpStruct
+
+    [<Benchmark>]
+    member _.FSharpEnum() = numbers |> Array.countBy createFSharpEnum
+
+    [<Benchmark>]
+    member _.CSharpStruct() = numbers |> Array.countBy createCSharpStruct
+
+    [<Benchmark>]
+    member _.CSharpEnum() = numbers |> Array.countBy createCSharpEnum
diff --git a/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/MicroPerf.fsproj b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/MicroPerf.fsproj
index c96d342298f..fc36640d7e6 100644
--- a/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/MicroPerf.fsproj
+++ b/tests/benchmarks/CompiledCodeBenchmarks/MicroPerf/MicroPerf.fsproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>$(FSharpNetCoreProductTargetFramework)</TargetFramework>
     <OutputType>Exe</OutputType>
@@ -11,6 +11,15 @@
     <OtherFlags>$(OtherFlags) --define:PREVIEW</OtherFlags>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="Equality\BasicTypes.fs" />
+    <Compile Include="Equality\FSharpCoreFunctions.fs" />
+    <Compile Include="Equality\Arrays.fs" />
+    <Compile Include="Equality\Floats.fs" />
+    <Compile Include="Equality\Tuples.fs" />
+    <Compile Include="Equality\ValueTypes.fs" />
+    <Compile Include="Equality\Misc.fs" />
+    <Compile Include="Equality\Structs.fs" />
+    <Compile Include="Equality\OptionsAndCo.fs" />
     <Compile Include="Async.fs" />
     <Compile Include="Conditions.fs" />
     <Compile Include="Collections.fs" />
diff --git a/tests/fsharp/core/letrec/test.fsx b/tests/fsharp/core/letrec/test.fsx
index cb9a6840981..5c27bba4b4e 100644
--- a/tests/fsharp/core/letrec/test.fsx
+++ b/tests/fsharp/core/letrec/test.fsx
@@ -18,8 +18,6 @@ let test t s1 s2 =
     stdout.WriteLine ("test "+t+" succeeded")   
 
 
-
-
 (* --------------------------------------------------------------------
  * Nested letrecs
  * -------------------------------------------------------------------- *)
diff --git a/tests/fsharp/core/members/basics-hw-mutrec/test.fs b/tests/fsharp/core/members/basics-hw-mutrec/test.fs
index 7a1fb2a049a..5b53e85196f 100644
--- a/tests/fsharp/core/members/basics-hw-mutrec/test.fs
+++ b/tests/fsharp/core/members/basics-hw-mutrec/test.fs
@@ -19,5570 +19,20 @@ let check s v1 v2 = test s (v1 = v2)
 //--------------------------------------------------------------
 // Test defining a record using object-expression syntax
 
-type RecordType = { a: int; mutable b: int }
-
-let rval = { new RecordType with a = 1 and b = 2 }
-let rvalaaa2 = { new RecordType 
-                        with a = 1 
-                        and b = 2 }
-
-test "fweoew091" (rval.a = 1)
-test "fweoew092" (rval.b = 2)
-rval.b <- 3
-test "fweoew093" (rval.b = 3)
-
-type RecordType2<'a,'b> = { a: 'a; mutable b: 'b }
-
-let rval2 = { new RecordType2<int,int> with a = 1 and b = 2 }
-
-test "fweoew091" (rval2.a = 1)
-test "fweoew092" (rval2.b = 2)
-rval2.b <- 3
-test "fweoew093" (rval2.b = 3)
-
-let f(x) = 
-  { new RecordType2<'a,int> with a = x and b = 2 }
-
-test "fweoew091" ((f(1)).a = 1)
-test "fweoew092" ((f(1)).b = 2)
-(f(1)).b <- 3
-test "fweoew093" ((f(1)).b = 2)
-
-
-
-
-
-
-//-----------------------------------------
-// Some simple object-expression tests
-
-let x0 = { new System.Object() with member __.GetHashCode() = 3 }
-let x1 = { new System.Windows.Forms.Form() with member __.GetHashCode() = 3 }
-
-//-----------------------------------------
-// Test defining an F# class
-
-
-type ClassType1 =
-  class
-     inherit System.Object 
-     val someField : string
-
-     interface IEnumerable 
-
-     abstract VirtualMethod1: string -> int
-     abstract VirtualMethod2: string * string -> int
-     abstract VirtualMethod1PostHoc: string -> int
-     abstract VirtualMethod2PostHoc: string * string -> int
-     default x.VirtualMethod1(s) = 3
-     default x.VirtualMethod2(s1,s2) = 3
-
-     new(s: string) = { inherit System.Object(); someField = "abc" }
-  end
-
-type ClassType1
-  with 
-     default x.VirtualMethod1PostHoc(s) = 3
-     default x.VirtualMethod2PostHoc(s1,s2) = 3
-     new(s1,s2) =  
-       { inherit System.Object(); someField = "constructor2" + s1 + s2 }
-  end
-
-
-
-type ClassType1 
-  with 
-    member x.GetEnumerator() = failwith "no implementation" 
-    interface IEnumerable 
-      with 
-        member x.GetEnumerator() = failwith "no implementation" 
-      end 
-    end
-let x = 1
-
-let x2 = { new ClassType1("a") with member __.GetHashCode() = 3 }
-let x3 = { new ClassType1("a") with member __.VirtualMethod1(s) = 4 }
-let x4 = { new ClassType1("a") with 
-                 member __.VirtualMethod1(s) = 5 
-                 member __.VirtualMethod2(s1,s2) = s1.Length + s2.Length }
-
-
-
-test "e09wckj2d" (try ignore((x2 :> IEnumerable).GetEnumerator()); false with Failure "no implementation" -> true)
-
-test "e09wckj2ddwdw" (try ignore(((x2 :> obj) :?> IEnumerable).GetEnumerator()); false with Failure "no implementation" -> true)
-test "e09wckj2defwe" (x2.VirtualMethod1("abc") = 3)
-test "e09wckd2jfew3" (x3.VirtualMethod1("abc") = 4)
-test "e09wckf3q2j" (x4.VirtualMethod1("abc") = 5)
-test "e09wckj321" (x4.VirtualMethod2("abc","d") = 4)
-
-
-//-----------------------------------------
-// Test inheriting from an F# type
-
-
-type ClassType2 =
-  class
-     inherit ClassType1 
-     val someField2 : string
-
-     override x.VirtualMethod1(s) = 2001
-     override x.VirtualMethod2(s1,s2) = s1.Length + s2.Length + String.length x.someField2
-
-     new(s) = { inherit ClassType1(s); someField2 = s }
-  end
-
-
-let x22 = { new ClassType2("a") with member __.GetHashCode() = 3 }
-let x32 = { new ClassType2("abc") with member __.VirtualMethod1(s) = 4002 }
-let x42 = { new ClassType2("abcd")  with
-              member __.VirtualMethod1(s) = 5004 
-              member __.VirtualMethod2(s1,s2) = 500 + s1.Length + s2.Length }
-
-test "e09wckj2ddwdw" (ignore(((x22 :> obj) :?> ClassType1)); true)
-test "e09wckj2ddwdw" (ignore((x22 :> ClassType1)); true)
-
-test "e09wckjd3" (x22.VirtualMethod1("abc") = 2001)
-test "e09wckjd3" (x32.VirtualMethod1("abc") = 4002)
-test "e09wckjfew" (x42.VirtualMethod1("abc") = 5004)
-test "e09wckjd3" (x22.VirtualMethod2("abcd","dqw") = 8)
-test "e09wckjd3" (x32.VirtualMethod2("abcd","dqw") = 10)
-
-
-
-//-----------------------------------------
-// Test defining an F# class
-
-
-module AbstractClassTest = begin
-
-    [<AbstractClass>]
-    type ClassType1 =
-      class
-         inherit System.Object 
-         val someField : string
-
-         interface IEnumerable 
-
-         abstract AbstractMethod1: string -> int
-         abstract AbstractMethod2: string * string -> int
-
-         new(s: string) = { inherit System.Object(); someField = "abc" }
-      end
-
-    type ClassType1
-      with 
-         interface IEnumerable with 
-            member x.GetEnumerator() = failwith "no implementation"
-         end
-
-      end
-
-    //let shouldGiveError1 = { new ClassType1("a") with GetHashCode() = 3 }
-    //let shouldGiveError2 = { new ClassType1("a") with AbstractMethod1(s) = 4 }
-    //let shouldGiveError3a = new ClassType1("a")
-    let x4 = { new ClassType1("a") with 
-                  member __.AbstractMethod1(s) = 5 
-                  member __.AbstractMethod2(s1,s2) = s1.Length + s2.Length }
-
-
-    do test "e09wckj2d" (try ignore((x2 :> IEnumerable).GetEnumerator()); false with Failure "no implementation" -> true)
-
-    test "e09wckj2ddwdw" (try ignore(((x2 :> obj) :?> IEnumerable).GetEnumerator()); false with Failure "no implementation" -> true)
-    test "e09wckf3q2j" (x4.AbstractMethod1("abc") = 5)
-    test "e09wckj321" (x4.AbstractMethod2("abc","d") = 4)
-
-
-    type ClassType2 =
-      class
-         inherit ClassType1 
-         val someField2 : string
-
-         override x.AbstractMethod1(s) = 2001
-         override x.AbstractMethod2(s1,s2) = s1.Length + s2.Length + String.length x.someField2
-
-         new(s) = { inherit ClassType1(s); someField2 = s }
-      end
-
-
-    let x22 = { new ClassType2("a") with member __.GetHashCode() = 3 }
-    let x32 = { new ClassType2("abc") with member __.AbstractMethod1(s) = 4002 }
-    let x42 = { new ClassType2("abcd")  with
-                  member __.AbstractMethod1(s) = 5004 
-                  member __.AbstractMethod2(s1,s2) = 500 + s1.Length + s2.Length }
-
-    do test "e09wckj2ddwdw" (ignore(((x22 :> obj) :?> ClassType1)); true)
-    do test "e09wckj2ddwdw" (ignore((x22 :> ClassType1)); true)
-
-    test "e09wckjd3" (x22.AbstractMethod1("abc") = 2001)
-    test "e09wckjd3" (x32.AbstractMethod1("abc") = 4002)
-    test "e09wckjfew" (x42.AbstractMethod1("abc") = 5004)
-    test "e09wckjd3" (x22.AbstractMethod2("abcd","dqw") = 8)
-    test "e09wckjd3" (x32.AbstractMethod2("abcd","dqw") = 10)
-
-    type ClassType3 =
-      class
-         inherit ClassType2
-         val someField3 : string
-
-         override x.AbstractMethod1(s) = 2001
-         override x.AbstractMethod2(s1,s2) = s1.Length + s2.Length + String.length x.someField2 + x.someField3.Length
-
-         new(s) = { inherit ClassType2(s); someField3 = s }
-      end
-
-
-
-end
-
-//-----------------------------------------
-//-----------------------------------------
-
-
-
-
-// Various rejected syntaxes for constructors:
-//   new(s: string) = { base=new Form(); x = "abc" }
-//   new ClassType1(s: string) : base() = { x = "abc" }
-//   new(s: string) = { inherit Form(); x = "abc" }
-//   member ClassType1(s: string) = new { inherit Form(); x = "abc" }
-//   member ClassType1(s: string) = { inherit Form(); x = "abc" }
-//   initializer(s: string) = { inherit Form(); x = "abc" }
-//   new ClassType1(s: string) = { inherit Form(); x = "abc" }
-
-//     new(s: string) = { inherit Form(); x = "abc" }
-
-//     new((s: string), (s2:string)) = { inherit Form(); x = s }
-
-
-//     abstract AbstractProperty: string
-//     abstract AbstractMutableProperty: string with get,set
-
-
-//     new(s: string) = { new ClassType1 with base=new Object() and x = "abc" }
-//     new(s: string) = { new ClassType1 with base=new Form() and x = "abc" }
-//     new(s: string) = ((new System.Object()) :?> ClassType1)
- 
-
-//-----------------------------------------
-// Thorough testing of members for records.
-
-module RecordTypeTest = begin
-
-    type AbstractType = 
-      { instanceField: string;
-        mutable mutableInstanceField: string;
-        instanceArray: string array;
-        instanceArray2: string array array;
-        mutableInstanceArray: string array;
-        mutableInstanceArray2: string array array; 
-        recursiveInstance: AbstractType;
-        }
-
-    let staticField = "staticField"
-    let mutableStaticField = ref "mutableStaticFieldInitialValue"
-    let staticArray = [| "staticArrayElement1"; "staticArrayElement2" |]
-    let mutableStaticArray = [| "mutableStaticArrayElement1InitialValue"; "mutableStaticArrayElement2InitialValue" |]
-
-    let NewAbstractValue(s) = 
-      let rec self =
-        { instanceField=s;
-          mutableInstanceField=s;
-          instanceArray=[| s;s |];
-          instanceArray2=[| [| s;s |];[| s;s |] |];
-          mutableInstanceArray =[| s;s |];
-          mutableInstanceArray2 =[| [| s;s |];[| s;s |] |]; 
-          recursiveInstance=self;
-        } 
-      self
-
-    type AbstractType 
-     with 
-      // properties
-      member x.ToString() = x.instanceField
-      member x.InstanceProperty = x.instanceField+".InstanceProperty"
-      member x.RecursiveInstance = x.recursiveInstance
-      member x.RecursiveInstanceMethod() = x.recursiveInstance
-      member x.MutableInstanceProperty
-        with get() = x.mutableInstanceField
-        and set(v:string) = x.mutableInstanceField <- v
-        
-      member x.InstanceIndexerCount = Array.length x.instanceArray
-
-      member x.InstanceIndexer
-         with get(idx) = x.instanceArray.[idx]
-      member x.InstanceIndexer2
-         with get(idx1,idx2) = x.instanceArray2.[idx1].[idx2]
-      member x.InstanceIndexer2Count1 = 2
-      member x.InstanceIndexer2Count2 = 2
-
-      member x.MutableInstanceIndexerCount = Array.length x.mutableInstanceArray
-
-      member x.MutableInstanceIndexer
-         with get (idx1) = x.mutableInstanceArray.[idx1]
-         and  set (idx1) (v:string) = x.mutableInstanceArray.[idx1] <- v
-
-      member x.MutableInstanceIndexer2
-         with get (idx1,idx2) = x.mutableInstanceArray2.[idx1].[idx2]
-         and  set (idx1,idx2) (v:string) = x.mutableInstanceArray2.[idx1].[idx2] <- v
-      member x.MutableInstanceIndexer2Count1 = 2
-      member x.MutableInstanceIndexer2Count2 = 2
-
-      static member StaticProperty = staticField
-      static member MutableStaticProperty
-              with get() = !mutableStaticField
-              and  set(v:string) = mutableStaticField := v
-        
-      static member StaticIndexer
-              with get(idx) = staticArray.[idx]
-         
-      static member StaticIndexerCount = Array.length staticArray
-
-      static member MutableStaticIndexer
-              with get(idx:int) = mutableStaticArray.[idx]
-              and  set(idx:int) (v:string) = mutableStaticArray.[idx] <- v
-
-      static member MutableStaticIndexerCount = Array.length mutableStaticArray
-
-      // methods
-      member x.InstanceMethod(s1:string) = Printf.sprintf "%s.InstanceMethod(%s)" x.instanceField s1
-      static member StaticMethod((s1:string),(s2:string)) = Printf.sprintf "AbstractType.StaticMethod(%s,%s)" s1 s2
-
-      // private versions of the above
-      member x.PrivateInstanceProperty = x.instanceField+".InstanceProperty"
-      member x.PrivateMutableInstanceProperty
-        with get() = x.mutableInstanceField
-        and  set(v:string) = x.mutableInstanceField <- v
-        
-      member x.PrivateInstanceIndexerCount = Array.length x.instanceArray
-
-      member x.PrivateInstanceIndexer
-         with get(idx) = x.instanceArray.[idx]
-      member x.PrivateInstanceIndexer2
-         with get(idx1,idx2) = x.instanceArray2.[idx1].[idx2]
-      member x.PrivateInstanceIndexer2Count1 = 2
-      member x.PrivateInstanceIndexer2Count2 = 2
-
-      member x.PrivateMutableInstanceIndexerCount = Array.length x.mutableInstanceArray
-
-      member x.PrivateMutableInstanceIndexer
-         with get (idx1) = x.mutableInstanceArray.[idx1]
-         and  set (idx1) (v:string) = x.mutableInstanceArray.[idx1] <- v
-
-      member x.PrivateMutableInstanceIndexer2
-         with get (idx1,idx2) = x.mutableInstanceArray2.[idx1].[idx2]
-         and  set (idx1,idx2) (v:string) = x.mutableInstanceArray2.[idx1].[idx2] <- v
-      member x.PrivateMutableInstanceIndexer2Count1 = 2
-      member x.PrivateMutableInstanceIndexer2Count2 = 2
-
-      static member PrivateStaticProperty = staticField
-      static member PrivateMutableStaticProperty
-              with get() = !mutableStaticField
-              and  set(v:string) = mutableStaticField := v
-        
-      static member PrivateStaticIndexer
-              with get(idx) = staticArray.[idx]
-         
-      static member PrivateStaticIndexerCount = Array.length staticArray
-
-      static member PrivateMutableStaticIndexer
-              with get(idx:int) = mutableStaticArray.[idx]
-              and  set(idx:int) (v:string) = mutableStaticArray.[idx] <- v
-
-      static member PrivateMutableStaticIndexerCount = Array.length mutableStaticArray
-
-      // methods
-      member x.PrivateInstanceMethod(s1:string) = Printf.sprintf "%s.InstanceMethod(%s)" x.instanceField s1
-      static member PrivateStaticMethod((s1:string),(s2:string)) = Printf.sprintf "AbstractType.StaticMethod(%s,%s)" s1 s2
-
-
-     end
-
-
-
-    // Test accesses of static properties, methods
-    do System.Console.WriteLine("AbstractType.StaticProperty = {0}", AbstractType.StaticProperty)
-    do AbstractType.MutableStaticProperty <- "MutableStaticProperty (mutated!)"
-    do System.Console.WriteLine("AbstractType.StaticIndexer(0) = {0}", AbstractType.StaticIndexer(0) )
-    do System.Console.WriteLine("AbstractType.StaticMethod(abc,def) = {0}", AbstractType.StaticMethod("abc","def") )
-    do System.Console.WriteLine("AbstractType.PrivateStaticProperty = {0}", AbstractType.PrivateStaticProperty )
-    do AbstractType.PrivateMutableStaticProperty <- "PrivateMutableStaticProperty (mutated!)"
-    do System.Console.WriteLine("AbstractType.PrivateStaticIndexer(0) = {0}", AbstractType.PrivateStaticIndexer(0) )
-    do System.Console.WriteLine("AbstractType.PrivateStaticMethod(abc,def) = {0}", AbstractType.PrivateStaticMethod("abc","def") )
-
-    // Torture this poor object
-    let xval = NewAbstractValue("abc")
-
-    // Test dynamic rediscovery of type
-    do test "e09wckdw" (not ((xval :> obj) :? IEnumerable))
-    do test "e09wckdwddw" (not ((xval :> obj) :? string))
-    do test "e09dwdw" (not ((xval :> obj) :? list<int>))
-    do test "e09dwwd2" ((xval :> obj) :? AbstractType)
-
-    // Test access of instance properties, methods through variables
-    do System.Console.WriteLine("abc.instanceField = {0}", xval.instanceField)
-    do System.Console.WriteLine("abc.InstanceMethod(def) = {0}", xval.InstanceMethod("def") )
-    do System.Console.WriteLine("abc.InstanceProperty = {0}", xval.InstanceProperty )
-    do System.Console.WriteLine("abc.InstanceIndexer(0) = {0}", xval.InstanceIndexer(0) )
-    do System.Console.WriteLine("abc.InstanceIndexer2(0,1) = {0}", xval.InstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.MutableInstanceProperty )
-    do xval.MutableInstanceProperty <- "MutableInstanceProperty (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.MutableInstanceProperty )
-    do System.Console.WriteLine("abc.MutableInstanceIndexer = {0}", xval.MutableInstanceIndexer(0) )
-    do xval.MutableInstanceIndexer(0) <- "MutableInstanceIndexer(0) (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceIndexer = {0}", xval.MutableInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.MutableInstanceIndexer2 = {0}", xval.MutableInstanceIndexer2(0,1) )
-    do xval.MutableInstanceIndexer2(0,1) <- "MutableInstanceIndexer2(0,1) (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceIndexer2 = {0}", xval.MutableInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.MutableInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateInstanceMethod(def) = {0}", xval.PrivateInstanceMethod("def") )
-    do System.Console.WriteLine("abc.PrivateInstanceProperty = {0}", xval.PrivateInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateInstanceIndexer(0) = {0}", xval.PrivateInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.PrivateInstanceIndexer2(0,1) = {0}", xval.PrivateInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", xval.PrivateMutableInstanceProperty )
-    do xval.PrivateMutableInstanceProperty <- "MutableInstanceProperty (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", xval.PrivateMutableInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer = {0}", xval.PrivateMutableInstanceIndexer(0) )
-    do xval.PrivateMutableInstanceIndexer(0) <- "MutableInstanceIndexer(0) (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer = {0}", xval.PrivateMutableInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer2 = {0}", xval.PrivateMutableInstanceIndexer2(0,1) )
-    do xval.PrivateMutableInstanceIndexer2(0,1) <- "MutableInstanceIndexer2(0,1) (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer2 = {0}", xval.PrivateMutableInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc..PrivateMutableInstanceProperty = {0}", xval.PrivateMutableInstanceProperty )
-
-    // repeat all the above through a long-path field lookup
-    do System.Console.WriteLine("abc.instanceField = {0}", xval.recursiveInstance.instanceField)
-    do System.Console.WriteLine("abc.InstanceMethod(def) = {0}", xval.recursiveInstance.InstanceMethod("def") )
-    do System.Console.WriteLine("abc.InstanceProperty = {0}", xval.recursiveInstance.InstanceProperty )
-    do System.Console.WriteLine("abc.InstanceIndexer(0) = {0}", xval.recursiveInstance.InstanceIndexer(0) )
-    do System.Console.WriteLine("abc.InstanceIndexer2(0,1) = {0}", xval.recursiveInstance.InstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.recursiveInstance.MutableInstanceProperty )
-    do xval.recursiveInstance.MutableInstanceProperty <- "MutableInstanceProperty (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.recursiveInstance.MutableInstanceProperty )
-    do System.Console.WriteLine("abc.MutableInstanceIndexer = {0}", xval.recursiveInstance.MutableInstanceIndexer(0) )
-    do xval.recursiveInstance.MutableInstanceIndexer(0) <- "MutableInstanceIndexer(0) (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceIndexer = {0}", xval.recursiveInstance.MutableInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.MutableInstanceIndexer2 = {0}", xval.recursiveInstance.MutableInstanceIndexer2(0,1) )
-    do xval.recursiveInstance.MutableInstanceIndexer2(0,1) <- "MutableInstanceIndexer2(0,1) (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceIndexer2 = {0}", xval.recursiveInstance.MutableInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.recursiveInstance.MutableInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateInstanceMethod(def) = {0}", xval.recursiveInstance.PrivateInstanceMethod("def") )
-    do System.Console.WriteLine("abc.PrivateInstanceProperty = {0}", xval.recursiveInstance.PrivateInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateInstanceIndexer(0) = {0}", xval.recursiveInstance.PrivateInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.PrivateInstanceIndexer2(0,1) = {0}", xval.recursiveInstance.PrivateInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", xval.recursiveInstance.PrivateMutableInstanceProperty )
-    do xval.recursiveInstance.PrivateMutableInstanceProperty <- "MutableInstanceProperty (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", xval.recursiveInstance.PrivateMutableInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer = {0}", xval.recursiveInstance.PrivateMutableInstanceIndexer(0) )
-    do xval.recursiveInstance.PrivateMutableInstanceIndexer(0) <- "MutableInstanceIndexer(0) (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer = {0}", xval.recursiveInstance.PrivateMutableInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer2 = {0}", xval.recursiveInstance.PrivateMutableInstanceIndexer2(0,1) )
-    do xval.recursiveInstance.PrivateMutableInstanceIndexer2(0,1) <- "MutableInstanceIndexer2(0,1) (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer2 = {0}", xval.recursiveInstance.PrivateMutableInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", xval.recursiveInstance.PrivateMutableInstanceProperty )
-
-
-    // repeat all the above through a long-path property lookup
-    do System.Console.WriteLine("abc.instanceField = {0}", xval.RecursiveInstance.instanceField)
-    do System.Console.WriteLine("abc.InstanceMethod(def) = {0}", xval.RecursiveInstance.InstanceMethod("def") )
-    do System.Console.WriteLine("abc.InstanceProperty = {0}", xval.RecursiveInstance.InstanceProperty )
-    do System.Console.WriteLine("abc.InstanceIndexer(0) = {0}", xval.RecursiveInstance.InstanceIndexer(0) )
-    do System.Console.WriteLine("abc.InstanceIndexer2(0,1) = {0}", xval.RecursiveInstance.InstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.RecursiveInstance.MutableInstanceProperty )
-    do xval.RecursiveInstance.MutableInstanceProperty <- "MutableInstanceProperty (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.RecursiveInstance.MutableInstanceProperty )
-    do System.Console.WriteLine("abc.MutableInstanceIndexer = {0}", xval.RecursiveInstance.MutableInstanceIndexer(0) )
-    do xval.RecursiveInstance.MutableInstanceIndexer(0) <- "MutableInstanceIndexer(0) (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceIndexer = {0}", xval.RecursiveInstance.MutableInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.MutableInstanceIndexer2 = {0}", xval.RecursiveInstance.MutableInstanceIndexer2(0,1) )
-    do xval.RecursiveInstance.MutableInstanceIndexer2(0,1) <- "MutableInstanceIndexer2(0,1) (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceIndexer2 = {0}", xval.RecursiveInstance.MutableInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.RecursiveInstance.MutableInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateInstanceMethod(def) = {0}", xval.RecursiveInstance.PrivateInstanceMethod("def") )
-    do System.Console.WriteLine("abc.PrivateInstanceProperty = {0}", xval.RecursiveInstance.PrivateInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateInstanceIndexer(0) = {0}", xval.RecursiveInstance.PrivateInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.PrivateInstanceIndexer2(0,1) = {0}", xval.RecursiveInstance.PrivateInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", xval.RecursiveInstance.PrivateMutableInstanceProperty )
-    do xval.RecursiveInstance.PrivateMutableInstanceProperty <- "MutableInstanceProperty (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", xval.RecursiveInstance.PrivateMutableInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer = {0}", xval.RecursiveInstance.PrivateMutableInstanceIndexer(0) )
-    do xval.RecursiveInstance.PrivateMutableInstanceIndexer(0) <- "MutableInstanceIndexer(0) (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer = {0}", xval.RecursiveInstance.PrivateMutableInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer2 = {0}", xval.RecursiveInstance.PrivateMutableInstanceIndexer2(0,1) )
-    do xval.RecursiveInstance.PrivateMutableInstanceIndexer2(0,1) <- "MutableInstanceIndexer2(0,1) (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer2 = {0}", xval.RecursiveInstance.PrivateMutableInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", xval.RecursiveInstance.PrivateMutableInstanceProperty )
-
-    // repeat all the above through a long-path method lookup
-    do System.Console.WriteLine("abc.instanceField = {0}", (xval.RecursiveInstanceMethod()).instanceField)
-    do System.Console.WriteLine("abc.InstanceMethod(def) = {0}", (xval.RecursiveInstanceMethod()).InstanceMethod("def") )
-    do System.Console.WriteLine("abc.InstanceProperty = {0}", (xval.RecursiveInstanceMethod()).InstanceProperty )
-    do System.Console.WriteLine("abc.InstanceIndexer(0) = {0}", (xval.RecursiveInstanceMethod()).InstanceIndexer(0) )
-    do System.Console.WriteLine("abc.InstanceIndexer2(0,1) = {0}", (xval.RecursiveInstanceMethod()).InstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", (xval.RecursiveInstanceMethod()).MutableInstanceProperty )
-    do (xval.RecursiveInstanceMethod()).MutableInstanceProperty <- "MutableInstanceProperty (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", (xval.RecursiveInstanceMethod()).MutableInstanceProperty )
-    do System.Console.WriteLine("abc.MutableInstanceIndexer = {0}", (xval.RecursiveInstanceMethod()).MutableInstanceIndexer(0) )
-    do (xval.RecursiveInstanceMethod()).MutableInstanceIndexer(0) <- "MutableInstanceIndexer(0) (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceIndexer = {0}", (xval.RecursiveInstanceMethod()).MutableInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.MutableInstanceIndexer2 = {0}", (xval.RecursiveInstanceMethod()).MutableInstanceIndexer2(0,1) )
-    do (xval.RecursiveInstanceMethod()).MutableInstanceIndexer2(0,1) <- "MutableInstanceIndexer2(0,1) (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceIndexer2 = {0}", (xval.RecursiveInstanceMethod()).MutableInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", (xval.RecursiveInstanceMethod()).MutableInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateInstanceMethod(def) = {0}", (xval.RecursiveInstanceMethod()).PrivateInstanceMethod("def") )
-    do System.Console.WriteLine("abc.PrivateInstanceProperty = {0}", (xval.RecursiveInstanceMethod()).PrivateInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateInstanceIndexer(0) = {0}", (xval.RecursiveInstanceMethod()).PrivateInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.PrivateInstanceIndexer2(0,1) = {0}", (xval.RecursiveInstanceMethod()).PrivateInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", (xval.RecursiveInstanceMethod()).PrivateMutableInstanceProperty )
-    do (xval.RecursiveInstanceMethod()).PrivateMutableInstanceProperty <- "MutableInstanceProperty (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", (xval.RecursiveInstanceMethod()).PrivateMutableInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer = {0}", (xval.RecursiveInstanceMethod()).PrivateMutableInstanceIndexer(0) )
-    do (xval.RecursiveInstanceMethod()).PrivateMutableInstanceIndexer(0) <- "MutableInstanceIndexer(0) (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer = {0}", (xval.RecursiveInstanceMethod()).PrivateMutableInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer2 = {0}", (xval.RecursiveInstanceMethod()).PrivateMutableInstanceIndexer2(0,1) )
-    do (xval.RecursiveInstanceMethod()).PrivateMutableInstanceIndexer2(0,1) <- "MutableInstanceIndexer2(0,1) (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer2 = {0}", (xval.RecursiveInstanceMethod()).PrivateMutableInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", (xval.RecursiveInstanceMethod()).PrivateMutableInstanceProperty )
-
-end
-
-//-----------------------------------------
-// Thorough testing of members for records.
-
-module UnionTypeTest = begin
-
-    type AbstractType =  A of AbstractType | B of string
-
-    let staticField = "staticField"
-    let mutableStaticField = ref "mutableStaticFieldInitialValue"
-    let staticArray = [| "staticArrayElement1"; "staticArrayElement2" |]
-    let mutableStaticArray = [| "mutableStaticArrayElement1InitialValue"; "mutableStaticArrayElement2InitialValue" |]
-
-    let NewAbstractValue(s) = B(s)
-
-    type AbstractType 
-     with 
-      // properties
-      member x.ToString() = match x with A _ -> "A" | B(s) -> "B"
-      member x.InstanceProperty = "instanceProperty"
-      member x.RecursiveInstance = match x with A y -> y | B s -> x
-      member x.RecursiveInstanceMethod() =  x.RecursiveInstance
-      member x.MutableInstanceProperty
-        with get() = x.InstanceProperty
-        and  set(v:string) = Printf.printf "called MutableInstanceProperty.set\n"
-        
-      member x.InstanceIndexerCount = 1
-
-      member x.InstanceIndexer
-         with get(idx) = "a"
-      member x.InstanceIndexer2
-         with get(idx1,idx2) = "a"
-      member x.InstanceIndexer2Count1 = 2
-      member x.InstanceIndexer2Count2 = 2
-
-      member x.MutableInstanceIndexerCount = 1
-
-      member x.MutableInstanceIndexer
-         with get (idx1) = "a"
-         and  set (idx1) (v:string) =  Printf.printf "called MutableInstanceIndexer.set\n"
-
-      member x.MutableInstanceIndexer2
-         with get (idx1,idx2) = "a"
-         and  set (idx1,idx2) (v:string) =  Printf.printf "called MutableInstanceIndexer2.set\n"
-      member x.MutableInstanceIndexer2Count1 = 2
-      member x.MutableInstanceIndexer2Count2 = 2
-
-      static member StaticProperty = staticField
-      static member MutableStaticProperty
-              with get() = !mutableStaticField
-              and  set(v:string) = mutableStaticField := v
-        
-      static member StaticIndexer
-              with get(idx) = staticArray.[idx]
-         
-      static member StaticIndexerCount = Array.length staticArray
-
-      static member MutableStaticIndexer
-              with get(idx:int) = mutableStaticArray.[idx]
-              and  set(idx:int) (v:string) = mutableStaticArray.[idx] <- v
-
-      static member MutableStaticIndexerCount = Array.length mutableStaticArray
-
-      // methods
-      member x.InstanceMethod(s1:string) = Printf.sprintf "InstanceMethod(%s)" s1
-      static member StaticMethod((s1:string),(s2:string)) = Printf.sprintf "AbstractType.StaticMethod(%s,%s)" s1 s2
-
-      // private versions of the above
-      member x.PrivateInstanceProperty = "InstanceProperty"
-      member x.PrivateMutableInstanceProperty
-        with get() = "a"
-        and  set(v:string) = Printf.printf "called mutator\n"
-        
-      member x.PrivateInstanceIndexerCount = 1
-
-      member x.PrivateInstanceIndexer
-         with get(idx) = "b"
-      member x.PrivateInstanceIndexer2
-         with get(idx1,idx2) = "c"
-      member x.PrivateInstanceIndexer2Count1 = 1
-      member x.PrivateInstanceIndexer2Count2 = 1
-
-      member x.PrivateMutableInstanceIndexerCount = 3
-
-      member x.PrivateMutableInstanceIndexer
-         with get (idx1) = "a"
-         and  set (idx1) (v:string) = Printf.printf "called mutator\n"
-
-      member x.PrivateMutableInstanceIndexer2
-         with get (idx1,idx2) = "a"
-         and  set (idx1,idx2) (v:string) = Printf.printf "called mutator\n"
-      member x.PrivateMutableInstanceIndexer2Count1 = 2
-      member x.PrivateMutableInstanceIndexer2Count2 = 2
-
-      static member PrivateStaticProperty = staticField
-      static member PrivateMutableStaticProperty
-              with get() = !mutableStaticField
-              and  set(v:string) = mutableStaticField := v
-        
-      static member PrivateStaticIndexer
-              with get(idx) = staticArray.[idx]
-         
-      static member PrivateStaticIndexerCount = Array.length staticArray
-
-      static member PrivateMutableStaticIndexer
-              with get(idx:int) = mutableStaticArray.[idx]
-              and  set(idx:int) (v:string) = mutableStaticArray.[idx] <- v
-
-      static member PrivateMutableStaticIndexerCount = Array.length mutableStaticArray
-
-      // methods
-      member x.PrivateInstanceMethod(s1:string) = Printf.sprintf "InstanceMethod(%s)"  s1
-      static member PrivateStaticMethod((s1:string),(s2:string)) = Printf.sprintf "AbstractType.StaticMethod(%s,%s)" s1 s2
-
-    end
-
-
-
-    // Test accesses of static properties, methods
-    do System.Console.WriteLine("AbstractType.StaticProperty = {0}", AbstractType.StaticProperty)
-    do AbstractType.MutableStaticProperty <- "MutableStaticProperty (mutated!)"
-    do System.Console.WriteLine("AbstractType.StaticIndexer(0) = {0}", AbstractType.StaticIndexer(0) )
-    do System.Console.WriteLine("AbstractType.StaticMethod(abc,def) = {0}", AbstractType.StaticMethod("abc","def") )
-    do System.Console.WriteLine("AbstractType.PrivateStaticProperty = {0}", AbstractType.PrivateStaticProperty )
-    do AbstractType.PrivateMutableStaticProperty <- "PrivateMutableStaticProperty (mutated!)"
-    do System.Console.WriteLine("AbstractType.PrivateStaticIndexer(0) = {0}", AbstractType.PrivateStaticIndexer(0) )
-    do System.Console.WriteLine("AbstractType.PrivateStaticMethod(abc,def) = {0}", AbstractType.PrivateStaticMethod("abc","def") )
-
-    // Torture this poor object
-    let xval = NewAbstractValue("abc")
-
-    // Test dynamic rediscovery of type
-    do test "e09wckdw" (not ((xval :> obj) :? IEnumerable))
-    do test "e09wckdwddw" (not ((xval :> obj) :? string))
-    do test "e09dwdw" (not ((xval :> obj) :? list<int>))
-    do test "e09dwwd2" ((xval :> obj) :? AbstractType)
-
-    // Test access of instance properties, methods through variables
-
-    do System.Console.WriteLine("abc.InstanceMethod(def) = {0}", xval.InstanceMethod("def") )
-    do System.Console.WriteLine("abc.InstanceProperty = {0}", xval.InstanceProperty )
-    do System.Console.WriteLine("abc.InstanceIndexer(0) = {0}", xval.InstanceIndexer(0) )
-    do System.Console.WriteLine("abc.InstanceIndexer2(0,1) = {0}", xval.InstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.MutableInstanceProperty )
-    do xval.MutableInstanceProperty <- "MutableInstanceProperty (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.MutableInstanceProperty )
-    do System.Console.WriteLine("abc.MutableInstanceIndexer = {0}", xval.MutableInstanceIndexer(0) )
-    do xval.MutableInstanceIndexer(0) <- "MutableInstanceIndexer(0) (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceIndexer = {0}", xval.MutableInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.MutableInstanceIndexer2 = {0}", xval.MutableInstanceIndexer2(0,1) )
-    do xval.MutableInstanceIndexer2(0,1) <- "MutableInstanceIndexer2(0,1) (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceIndexer2 = {0}", xval.MutableInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.MutableInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateInstanceMethod(def) = {0}", xval.PrivateInstanceMethod("def") )
-    do System.Console.WriteLine("abc.PrivateInstanceProperty = {0}", xval.PrivateInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateInstanceIndexer(0) = {0}", xval.PrivateInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.PrivateInstanceIndexer2(0,1) = {0}", xval.PrivateInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", xval.PrivateMutableInstanceProperty )
-    do xval.PrivateMutableInstanceProperty <- "MutableInstanceProperty (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", xval.PrivateMutableInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer = {0}", xval.PrivateMutableInstanceIndexer(0) )
-    do xval.PrivateMutableInstanceIndexer(0) <- "MutableInstanceIndexer(0) (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer = {0}", xval.PrivateMutableInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer2 = {0}", xval.PrivateMutableInstanceIndexer2(0,1) )
-    do xval.PrivateMutableInstanceIndexer2(0,1) <- "MutableInstanceIndexer2(0,1) (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer2 = {0}", xval.PrivateMutableInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc..PrivateMutableInstanceProperty = {0}", xval.PrivateMutableInstanceProperty )
-
-    // repeat all the above through a long-path field lookup
-
-    do System.Console.WriteLine("abc.InstanceMethod(def) = {0}", xval.RecursiveInstance.InstanceMethod("def") )
-    do System.Console.WriteLine("abc.InstanceProperty = {0}", xval.RecursiveInstance.InstanceProperty )
-    do System.Console.WriteLine("abc.InstanceIndexer(0) = {0}", xval.RecursiveInstance.InstanceIndexer(0) )
-    do System.Console.WriteLine("abc.InstanceIndexer2(0,1) = {0}", xval.RecursiveInstance.InstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.RecursiveInstance.MutableInstanceProperty )
-    do xval.RecursiveInstance.MutableInstanceProperty <- "MutableInstanceProperty (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.RecursiveInstance.MutableInstanceProperty )
-    do System.Console.WriteLine("abc.MutableInstanceIndexer = {0}", xval.RecursiveInstance.MutableInstanceIndexer(0) )
-    do xval.RecursiveInstance.MutableInstanceIndexer(0) <- "MutableInstanceIndexer(0) (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceIndexer = {0}", xval.RecursiveInstance.MutableInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.MutableInstanceIndexer2 = {0}", xval.RecursiveInstance.MutableInstanceIndexer2(0,1) )
-    do xval.RecursiveInstance.MutableInstanceIndexer2(0,1) <- "MutableInstanceIndexer2(0,1) (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceIndexer2 = {0}", xval.RecursiveInstance.MutableInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.RecursiveInstance.MutableInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateInstanceMethod(def) = {0}", xval.RecursiveInstance.PrivateInstanceMethod("def") )
-    do System.Console.WriteLine("abc.PrivateInstanceProperty = {0}", xval.RecursiveInstance.PrivateInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateInstanceIndexer(0) = {0}", xval.RecursiveInstance.PrivateInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.PrivateInstanceIndexer2(0,1) = {0}", xval.RecursiveInstance.PrivateInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", xval.RecursiveInstance.PrivateMutableInstanceProperty )
-    do xval.RecursiveInstance.PrivateMutableInstanceProperty <- "MutableInstanceProperty (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", xval.RecursiveInstance.PrivateMutableInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer = {0}", xval.RecursiveInstance.PrivateMutableInstanceIndexer(0) )
-    do xval.RecursiveInstance.PrivateMutableInstanceIndexer(0) <- "MutableInstanceIndexer(0) (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer = {0}", xval.RecursiveInstance.PrivateMutableInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer2 = {0}", xval.RecursiveInstance.PrivateMutableInstanceIndexer2(0,1) )
-    do xval.RecursiveInstance.PrivateMutableInstanceIndexer2(0,1) <- "MutableInstanceIndexer2(0,1) (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer2 = {0}", xval.RecursiveInstance.PrivateMutableInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", xval.RecursiveInstance.PrivateMutableInstanceProperty )
-
-
-    // repeat all the above through a long-path property lookup
-    do System.Console.WriteLine("abc.InstanceMethod(def) = {0}", xval.RecursiveInstance.InstanceMethod("def") )
-    do System.Console.WriteLine("abc.InstanceProperty = {0}", xval.RecursiveInstance.InstanceProperty )
-    do System.Console.WriteLine("abc.InstanceIndexer(0) = {0}", xval.RecursiveInstance.InstanceIndexer(0) )
-    do System.Console.WriteLine("abc.InstanceProperty = {0}", xval.RecursiveInstance.InstanceProperty )
-    do System.Console.WriteLine("abc.InstanceProperty = {0}", xval.RecursiveInstance.InstanceProperty )
-    do System.Console.WriteLine("abc.InstanceProperty = {0}", xval.RecursiveInstance.InstanceProperty )
-    do System.Console.WriteLine("abc.InstanceProperty = {0}", xval.RecursiveInstance.InstanceProperty )
-    do System.Console.WriteLine("abc.InstanceIndexer2(0,1) = {0}", xval.RecursiveInstance.InstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.RecursiveInstance.MutableInstanceProperty )
-    do xval.RecursiveInstance.MutableInstanceProperty <- "MutableInstanceProperty (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.RecursiveInstance.MutableInstanceProperty )
-    do System.Console.WriteLine("abc.MutableInstanceIndexer = {0}", xval.RecursiveInstance.MutableInstanceIndexer(0) )
-    do xval.RecursiveInstance.MutableInstanceIndexer(0) <- "MutableInstanceIndexer(0) (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceIndexer = {0}", xval.RecursiveInstance.MutableInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.MutableInstanceIndexer2 = {0}", xval.RecursiveInstance.MutableInstanceIndexer2(0,1) )
-    do xval.RecursiveInstance.MutableInstanceIndexer2(0,1) <- "MutableInstanceIndexer2(0,1) (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceIndexer2 = {0}", xval.RecursiveInstance.MutableInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", xval.RecursiveInstance.MutableInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateInstanceMethod(def) = {0}", xval.RecursiveInstance.PrivateInstanceMethod("def") )
-    do System.Console.WriteLine("abc.PrivateInstanceProperty = {0}", xval.RecursiveInstance.PrivateInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateInstanceIndexer(0) = {0}", xval.RecursiveInstance.PrivateInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.PrivateInstanceIndexer2(0,1) = {0}", xval.RecursiveInstance.PrivateInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", xval.RecursiveInstance.PrivateMutableInstanceProperty )
-    do xval.RecursiveInstance.PrivateMutableInstanceProperty <- "MutableInstanceProperty (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", xval.RecursiveInstance.PrivateMutableInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer = {0}", xval.RecursiveInstance.PrivateMutableInstanceIndexer(0) )
-    do xval.RecursiveInstance.PrivateMutableInstanceIndexer(0) <- "MutableInstanceIndexer(0) (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer = {0}", xval.RecursiveInstance.PrivateMutableInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer2 = {0}", xval.RecursiveInstance.PrivateMutableInstanceIndexer2(0,1) )
-    do xval.RecursiveInstance.PrivateMutableInstanceIndexer2(0,1) <- "MutableInstanceIndexer2(0,1) (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer2 = {0}", xval.RecursiveInstance.PrivateMutableInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", xval.RecursiveInstance.PrivateMutableInstanceProperty )
-
-    // repeat all the above through a long-path method lookup
-    do System.Console.WriteLine("abc.InstanceMethod(def) = {0}", (xval.RecursiveInstanceMethod()).InstanceMethod("def") )
-    do System.Console.WriteLine("abc.InstanceProperty = {0}", (xval.RecursiveInstanceMethod()).InstanceProperty )
-    do System.Console.WriteLine("abc.InstanceIndexer(0) = {0}", (xval.RecursiveInstanceMethod()).InstanceIndexer(0) )
-    do System.Console.WriteLine("abc.InstanceIndexer2(0,1) = {0}", (xval.RecursiveInstanceMethod()).InstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", (xval.RecursiveInstanceMethod()).MutableInstanceProperty )
-    do (xval.RecursiveInstanceMethod()).MutableInstanceProperty <- "MutableInstanceProperty (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", (xval.RecursiveInstanceMethod()).MutableInstanceProperty )
-    do System.Console.WriteLine("abc.MutableInstanceIndexer = {0}", (xval.RecursiveInstanceMethod()).MutableInstanceIndexer(0) )
-    do (xval.RecursiveInstanceMethod()).MutableInstanceIndexer(0) <- "MutableInstanceIndexer(0) (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceIndexer = {0}", (xval.RecursiveInstanceMethod()).MutableInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.MutableInstanceIndexer2 = {0}", (xval.RecursiveInstanceMethod()).MutableInstanceIndexer2(0,1) )
-    do (xval.RecursiveInstanceMethod()).MutableInstanceIndexer2(0,1) <- "MutableInstanceIndexer2(0,1) (mutated!)"
-    do System.Console.WriteLine("abc.MutableInstanceIndexer2 = {0}", (xval.RecursiveInstanceMethod()).MutableInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.MutableInstanceProperty = {0}", (xval.RecursiveInstanceMethod()).MutableInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateInstanceMethod(def) = {0}", (xval.RecursiveInstanceMethod()).PrivateInstanceMethod("def") )
-    do System.Console.WriteLine("abc.PrivateInstanceProperty = {0}", (xval.RecursiveInstanceMethod()).PrivateInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateInstanceIndexer(0) = {0}", (xval.RecursiveInstanceMethod()).PrivateInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.PrivateInstanceIndexer2(0,1) = {0}", (xval.RecursiveInstanceMethod()).PrivateInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", (xval.RecursiveInstanceMethod()).PrivateMutableInstanceProperty )
-    do (xval.RecursiveInstanceMethod()).PrivateMutableInstanceProperty <- "MutableInstanceProperty (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", (xval.RecursiveInstanceMethod()).PrivateMutableInstanceProperty )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer = {0}", (xval.RecursiveInstanceMethod()).PrivateMutableInstanceIndexer(0) )
-    do (xval.RecursiveInstanceMethod()).PrivateMutableInstanceIndexer(0) <- "MutableInstanceIndexer(0) (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer = {0}", (xval.RecursiveInstanceMethod()).PrivateMutableInstanceIndexer(0) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer2 = {0}", (xval.RecursiveInstanceMethod()).PrivateMutableInstanceIndexer2(0,1) )
-    do (xval.RecursiveInstanceMethod()).PrivateMutableInstanceIndexer2(0,1) <- "MutableInstanceIndexer2(0,1) (mutated!)"
-    do System.Console.WriteLine("abc.PrivateMutableInstanceIndexer2 = {0}", (xval.RecursiveInstanceMethod()).PrivateMutableInstanceIndexer2(0,1) )
-    do System.Console.WriteLine("abc.PrivateMutableInstanceProperty = {0}", (xval.RecursiveInstanceMethod()).PrivateMutableInstanceProperty )
-
-end
-
-
-//---------------------------------------------------------------------
-// Test that we can change the default structural comparison semantics
-
-
-module OverrideIComparableOnClassTest = begin
-
-  type MyStringClass = 
-    class 
-      val cache: int 
-      val v: string 
-      interface IStructuralComparable with 
-         member x.CompareTo(y:obj,comp:System.Collections.IComparer) = compare x.v (y :?> MyStringClass).v 
-      end 
-      interface IStructuralEquatable with 
-         member x.GetHashCode(comp:System.Collections.IEqualityComparer) = hash(x.v) 
-         member x.Equals(y:obj,comp:System.Collections.IEqualityComparer) = (compare x.v (y :?> MyStringClass).v ) = 0
-      end 
-      member x.Length = x.cache
-      new(s:string) = { inherit Object(); cache=s.Length; v=s }
-    end
-
-  let s1 = new MyStringClass("abc")
-  let s2 = new MyStringClass("def")
-  let s3 = new MyStringClass("abc")
-  let s4 = new MyStringClass("abcd")
-  do test "cepoiwelk" (s1.Length = 3)
-  do test "cepoiwelk" (s2.Length = 3)
-  let testc (s1:MyStringClass) (s2:MyStringClass) = 
-    test "cepoiwelk1" ((s1 = s2) = (s1.v = s2.v))
-    test "cepoiwelk2" ((s1 < s2) = (s1.v < s2.v))
-    test "cepoiwelk3" ((s1 > s2) = (s1.v > s2.v))
-    test "cepoiwelk4" ((s1 <= s2) = (s1.v <= s2.v))
-    test "cepoiwelk5" ((s1 >= s2) = (s1.v >= s2.v))
-    test "cepoiwelk6" ((s1 <> s2) = (s1.v <> s2.v))
-    Printf.printf "hash s1 = %d\n" (hash(s1))
-    Printf.printf "hash s1.v = %d\n" (hash(s1.v))
-    test "cepoiwelk7" (hash(s1) = hash(s1.v))
-    test "cepoiwelk8" (hash(s2) = hash(s2.v)) 
-
-  do testc s1 s2
-  do testc s1 s3
-  do testc s2 s3
-  do testc s2 s1 
-  do testc s3 s1 
-  do testc s3 s2 
-  do testc s4 s2 
-end
-
-module OverrideIComparableOnRecordTest = begin
-
-  [<CustomEquality; CustomComparison>]
-  type MyStringClass = { cache: int; v: string  }
-    with 
-      interface IStructuralComparable with 
-         member x.CompareTo(y:obj,comp:System.Collections.IComparer) = compare x.v (y :?> MyStringClass).v 
-      end 
-      interface IStructuralEquatable with 
-         member x.GetHashCode(comp:System.Collections.IEqualityComparer) = hash(x.v) 
-         member x.Equals(y:obj,comp:System.Collections.IEqualityComparer) = (compare x.v (y :?> MyStringClass).v ) = 0
-      end 
-      member x.Length = x.cache
-      static member Create(s:string) = { cache=s.Length; v=s }
-    end
-
-
-  let s1 = MyStringClass.Create("abc")
-  let s2 = MyStringClass.Create("def")
-  let s3 = MyStringClass.Create("abc")
-  let s4 = MyStringClass.Create("abcd")
-  do test "recd-cepoiwelk" (s1.Length = 3)
-  do test "recd-cepoiwelk" (s2.Length = 3)
-  let testc s1 s2 = 
-    test "recd-cepoiwelk1" ((s1 = s2) = (s1.v = s2.v))
-    test "recd-cepoiwelk2" ((s1 < s2) = (s1.v < s2.v))
-    test "recd-cepoiwelk3" ((s1 > s2) = (s1.v > s2.v))
-    test "recd-cepoiwelk4" ((s1 <= s2) = (s1.v <= s2.v))
-    test "recd-cepoiwelk5" ((s1 >= s2) = (s1.v >= s2.v))
-    test "recd-cepoiwelk6" ((s1 <> s2) = (s1.v <> s2.v))
-    Printf.printf "hash s1 = %d\n" (hash(s1))
-    Printf.printf "hash s1.v = %d\n" (hash(s1.v))
-    test "recd-cepoiwelk7" (hash(s1) = hash(s1.v))
-    test "recd-cepoiwelk8" (hash(s2) = hash(s2.v)) 
-
-  do testc s1 s2
-  do testc s1 s3
-  do testc s2 s3
-  do testc s2 s1 
-  do testc s3 s1 
-  do testc s3 s2 
-  do testc s4 s2 
-end
-
-module OverrideIComparableOnUnionTest = begin
-
-  [<CustomEquality; CustomComparison>]
-  type MyStringClass = A of int * string | B of int * string
-    with 
-      member x.Value = match x with A(_,s) | B(_,s) -> s 
-      interface IStructuralComparable with 
-         member x.CompareTo(y:obj,comp:System.Collections.IComparer) = compare x.Value (y :?> MyStringClass).Value
-      end 
-      interface IStructuralEquatable with 
-         member x.GetHashCode(comp:System.Collections.IEqualityComparer) = hash(x.Value)
-         member x.Equals(y:obj,comp:System.Collections.IEqualityComparer) = x.Value = (y :?> MyStringClass).Value
-      end 
-      member x.Length = match x with A(n,_) | B(n,_) -> n
-      static member Create(s:string) = A(s.Length,s)
-    end
-
-
-  let s1 = MyStringClass.Create("abc")
-  let s2 = MyStringClass.Create("def")
-  let s3 = MyStringClass.Create("abc")
-  let s4 = MyStringClass.Create("abcd")
-  do test "union-cepoiwelk" (s1.Length = 3)
-  do test "union-cepoiwelk" (s2.Length = 3)
-  let testc (s1:MyStringClass) (s2:MyStringClass) = 
-    test "union-cepoiwelk1" ((s1 = s2) = (s1.Value = s2.Value))
-    test "union-cepoiwelk2" ((s1 < s2) = (s1.Value < s2.Value))
-    test "union-cepoiwelk3" ((s1 > s2) = (s1.Value > s2.Value))
-    test "union-cepoiwelk4" ((s1 <= s2) = (s1.Value <= s2.Value))
-    test "union-cepoiwelk5" ((s1 >= s2) = (s1.Value >= s2.Value))
-    test "union-cepoiwelk6" ((s1 <> s2) = (s1.Value <> s2.Value))
-    Printf.printf "hash s1 = %d\n" (hash(s1))
-    Printf.printf "hash s1.Value = %d\n" (hash(s1.Value))
-    test "union-cepoiwelk7" (hash(s1) = hash(s1.Value))
-    test "union-cepoiwelk8" (hash(s2) = hash(s2.Value)) 
-
-  do testc s1 s2
-  do testc s1 s3
-  do testc s2 s3
-  do testc s2 s1 
-  do testc s3 s1 
-  do testc s3 s2 
-  do testc s4 s2 
-end
-
-//---------------------------------------------------------------------
-// Test we can define an attribute
-
-
-type DontPressThisButtonAttribute = 
-  class 
-    inherit System.Attribute
-    val v: string 
-    member x.Message = x.v
-    new(s:string) = { inherit System.Attribute(); v=s }
-  end
-
-// BUG:
-type [<DontPressThisButton("Please don't press this again")>] button = Buttpon
-let [<DontPressThisButton("Please don't press this again")>] button () = 1
-
-
-//---------------------------------------------------------------------
-// Test we can use base calls
-
-
-
-type MyCanvas2 = 
-  class 
-    inherit Form 
-    override x.OnPaint(args) =  Printf.printf "OnPaint\n"; base.OnPaint(args)
-
-    new() = { inherit Form(); }
-  end
-
-let form2 = new MyCanvas2()
-
-
-//---------------------------------------------------------------------
-// Test we can inherit from the Event<'a> type to define our listeners
-
-let (|>) x f = f x
-
-(*
-type MyEventListeners<'a>  =
-  class
-    inherit Event<'a> 
-
-    val mutable listeners2: (Handler<'a>) list 
-
-    member l.Fire(x : 'a) = 
-      let arg = new SimpleEventArgs<_>(x) 
-      l.listeners2 |> List.iter (fun d -> ignore(d.Invoke((null:obj),arg))) 
-
-    new() = 
-      { inherit Event<'a>(); 
-        listeners2 = [] }
-
-  end
-
-*)
-
-(*
-type MyCanvas2 = 
-  class 
-    inherit Form
-    member x.Redraw : Event<PaintEventArgs>
-    new: unit -> MyCanvas2
-  end
-*)
-
-(*
-type MyCanvas2 = 
-  class 
-    inherit Form
-    val redrawListeners: MyEventListeners<PaintEventArgs>
-    member x.Redraw = x.redrawListeners
-    override x.OnPaint(args) = x.redrawListeners.Fire(args)
-
-    new() = { inherit Form(); redrawListeners= new MyEventListeners<PaintEventArgs>() }
-  end
-*)
-
-(*
-class MyCanvas2() =
-  let l = MyEventListeners<PaintEventArgs>() 
-  object
-    inherit Form()
-    member x.Redraw = l
-    override x.OnPaint(args) = l.Fire(args)
-  end
-
-class MyCanvas2 =
-  let l = MyEventListeners<PaintEventArgs>() 
-  object
-    inherit Form
-    member x.Redraw = l
-    override x.OnPaint(args) = l.Fire(args)
-  end
-*)
-
-(*
-let form = new MyCanvas2()
-// form.Paint.Add(...)
-// form.add_Paint(...)
-form.Redraw.AddHandler(new Handler(fun _ args -> Printf.printf "OnRedraw\n"))
-form.Redraw.Add(fun args -> Printf.printf "OnRedraw\n")
-
-
-form.Activate()
-Application.Run(form)
-*)
-
-//x.add_Redraw
-
-//---------------------------------------------------------------------
-// Test we can define an exception
-
-type MyException =
-  class 
-    inherit System.Exception
-    val v: string 
-    member x.Message = x.v
-    new(s:string) = { inherit System.Exception(); v=s }
-  end
-
-let _ = try raise(new MyException("help!")) with :? MyException as me -> Printf.printf "message = %s\n" me.Message
-
-//---------------------------------------------------------------------
-// Test we can define and subscribe to an interface
-
-(*
-type IMyInterface =
-  interface
-    abstract MyMethod: string -> int
-  end
-*)
-
-// type IMyStructuralConstraint = < MyMethod: string -> int >
-// 'a :> < MyMethod: string -> int >
-// 'a :> IMyStructuralConstraint
-// 'a : IMyStructuralConstraint
-
-
-//---------------------------------------------------------------------
-// Test we can define and subscribe to a generic interface
-
-    
-//---------------------------------------------------------------------
-// Test we can define a struct
-
-
-(*
-type MyStruct =
-  struct
-    val x: int
-    val y: int
-  end
-*)
-
-
-//---------------------------------------------------------------------
-// Test we can define a generic struct
-
-//---------------------------------------------------------------------
-// Test we can define a class with no fields
-
-type NoFieldClass = 
-  class 
-    new() = { inherit System.Object() }
-  end
-
-//---------------------------------------------------------------------
-// Test we can implement more than one interface on a class
-
-module MultiInterfaceTest = begin
-  type PrivateInterfaceA1 = interface abstract M1 : unit -> unit end
-  type PrivateInterfaceA2 = interface abstract M2 : unit -> unit end
-
-  type C1 = 
-    class 
-      interface PrivateInterfaceA1 with 
-        member x.M1() = ()
-      end
-      interface PrivateInterfaceA2 with 
-        member x.M2() = ()
-      end
-   end
-end
-
-module MultiInterfaceTestNameConflict = begin
-  type PrivateInterfaceA1 = interface abstract M : unit -> unit end
-  type PrivateInterfaceA2 = interface abstract M : unit -> unit end
-
-  type C1 = 
-    class 
-      interface PrivateInterfaceA1 with 
-        member x.M() = ()
-      end
-      interface PrivateInterfaceA2 with 
-        member x.M() = ()
-      end
-   end
-end
-
-
-module GenericMultiInterfaceTestNameConflict = begin
-  type PrivateInterfaceA1<'a> = interface abstract M : 'a -> 'a end
-  type PrivateInterfaceA2<'a> = interface abstract M : 'a -> 'a end
-
-  type C1 = 
-    class 
-      interface PrivateInterfaceA1<string> with 
-        member x.M(y) = y
-      end
-      interface PrivateInterfaceA2<int> with 
-        member x.M(y) = y
-      end
-   end
-end
-
-
-module DeepInterfaceInheritance = begin
-  type InterfaceA1 = interface abstract M1 : int -> int end
-  type InterfaceA2 = interface inherit InterfaceA1 abstract M2 : int -> int end
-  type InterfaceA3 = interface inherit InterfaceA1  inherit InterfaceA2 abstract M3 : int -> int end
-
-  type C1 = 
-    class 
-      interface InterfaceA2 with 
-        member x.M1(y) = y 
-        member x.M2(y) = y + y 
-      end
-      new() = { inherit Object(); }
-   end
-  type C2 = 
-    class 
-      interface InterfaceA3 with 
-        member x.M1(y) = y
-        member x.M2(y) = y + y
-        member x.M3(y) = y + y + y
-      end
-      new() = { inherit Object(); }
-   end
-  type C3 = 
-    class 
-      interface InterfaceA2 with 
-        member x.M1(y) = y
-        member x.M2(y) = y + y
-      end
-      interface InterfaceA3 with 
-        member x.M3(y) = y + y + y
-      end
-      new() = { inherit Object(); }
-   end
-
-  do test "fewopvrej1" (((new C1()) :> InterfaceA1).M1(4) = 4)
-  do test "fewopvrej2" (((new C1()) :> InterfaceA2).M2(4) = 8)
-   
-  do test "fewopvrej3" (((new C2()) :> InterfaceA1).M1(4) = 4)
-  do test "fewopvrej4" (((new C2()) :> InterfaceA2).M2(4) = 8)
-  do test "fewopvrej5" (((new C2()) :> InterfaceA3).M3(4) = 12)
-  do test "fewopvrej6" (((new C2()) :> InterfaceA3).M1(4) = 4)
-  do test "fewopvrej7" (((new C2()) :> InterfaceA3).M2(4) = 8)
-   
-  do test "fewopvrej8" (((new C3()) :> InterfaceA1).M1(4) = 4)
-  do test "fewopvrej9" (((new C3()) :> InterfaceA2).M2(4) = 8)
-  do test "fewopvrej10" (((new C3()) :> InterfaceA3).M3(4) = 12)
-  do test "fewopvrej11" (((new C3()) :> InterfaceA3).M1(4) = 4)
-  do test "fewopvrej12" (((new C3()) :> InterfaceA3).M2(4) = 8)
-   
-end
-
-module DeepGenericInterfaceInheritance = begin
-  type InterfaceA1<'a> = interface abstract M1 : 'a -> 'a end
-  type InterfaceA2<'b> = interface inherit InterfaceA1<'b list> abstract M2 : 'b * 'b list -> 'b list end
-  type InterfaceA3 = interface inherit InterfaceA2<string>  abstract M3 : string list -> string list end
-
-  type C1 = 
-    class 
-      interface InterfaceA2<int> with 
-        member this.M1(y) = 1::y 
-        member this.M2(x,y) = x::y
-      end
-      new() = { inherit Object(); }
-   end
-  type C2 = 
-    class 
-      interface InterfaceA3 with 
-        member this.M1(y) = "a" :: y
-        member this.M2(x,y) = x :: y
-        member this.M3(y) = "a" :: "b" :: "c" :: y
-      end
-      new() = { inherit Object(); }
-   end
-  type C3 = 
-    class 
-      interface InterfaceA2<string> with 
-        member this.M1(y) = "a" :: y
-        member this.M2(x,y) = x :: y
-      end
-      interface InterfaceA3 with 
-        member x.M3(y) = "a" :: "b" :: "c" :: y
-      end
-      new() = { inherit Object(); }
-   end
-
-  test "fewopvrej1" (((new C1()) :> InterfaceA1<int list>).M1([1]) = [1;1])
-  test "fewopvrej2" (((new C1()) :> InterfaceA2<int>).M2(3,[1]) = [3;1])
-   
-  test "fewopvrej3" (((new C2()) :> InterfaceA1<string list>).M1(["hi"]) = ["a";"hi"])
-  test "fewopvrej4" (((new C2()) :> InterfaceA2<string>).M1(["hi"]) = ["a";"hi"])
-  test "fewopvrej4" (((new C2()) :> InterfaceA2<string>).M2("a",["hi"]) = ["a";"hi"])
-  test "fewopvrej5" (((new C2()) :> InterfaceA3).M3(["hi"]) = ["a";"b";"c";"hi"])
-  test "fewopvrej6" (((new C2()) :> InterfaceA3).M1(["hi"]) = ["a";"hi"])
-  test "fewopvrej7" (((new C2()) :> InterfaceA3).M2("a",["hi"]) = ["a";"hi"])
-   
-  test "fewopvrej8" (((new C3()) :> InterfaceA1<string list>).M1(["hi"]) = ["a";"hi"])
-  test "fewopvrej8" (((new C3()) :> InterfaceA2<string>).M1(["hi"]) = ["a";"hi"])
-  test "fewopvrej9" (((new C3()) :> InterfaceA2<string>).M2("a",["hi"]) = ["a";"hi"])
-  test "fewopvrej10" (((new C3()) :> InterfaceA3).M3(["hi"]) = ["a";"b";"c";"hi"])
-  test "fewopvrej11" (((new C3()) :> InterfaceA3).M1(["hi"]) = ["a";"hi"])
-  test "fewopvrej12" (((new C3()) :> InterfaceA3).M2("a",["hi"]) = ["a";"hi"])
-   
-end
-
-
-module PointTest =  begin
-
-
-  type Point =
-   class
-     new(x_init) = { inherit System.Object(); x_init = x_init; x = x_init } 
-     val x_init : int
-     val mutable x : int
-     member p.X = p.x
-     member p.Offset = p.x - p.x_init
-     member p.Move d1 d2 = p.x <- p.x + d1 + d2
-     static member TwoArgs d1 d2 = d1 + d2
-     static member TwoPatternArgs [d1] [d2] = d1 + d2
-     static member ThreeArgs d1 d2 d3 = d1 + d2 + d3
-     static member ThreePatternArgs [d1] [d2] [d3] = d1 + d2 + d3
-     member p.InstanceTwoArgs d1 d2 = p.x + d1 + d2
-     member p.InstanceTwoPatternArgs [d1] [d2] = p.x +  d1 + d2
-     member p.InstanceThreeArgs d1 d2 d3 = p.x +  d1 + d2 + d3
-     member p.InstanceThreePatternArgs [d1] [d2] [d3] = p.x + d1 + d2 + d3
-   end
-
-  type Point_with_no_inherits_clause =
-    class
-     new x_init = { x_init = x_init; x = x_init } 
-     val x_init : int
-     val mutable x : int
-     member p.X = p.x
-     member p.Offset = p.x - p.x_init
-     member p.Move d1 d2 = p.x <- p.x + d1 + d2
-    end
-
-  
-  let p = (new Point_with_no_inherits_clause(3)) 
-  let f = p.Move 4 
-  do test "wdfjcdwkj1" (p.X = 3)
-  do f 4
-  do test "wdfjcdwkj2" (p.X = 11)
-  do f 1
-  do test "wdfjcdwkj3" (p.X = 16)
-  do test "wdfjcdwkj4" (Point.TwoArgs 1 2 = 3)
-  do test "wdfjcdwkj5" (Point.TwoPatternArgs [1] [2] = 3)
-  do test "wdfjcdwkj6" (Point.ThreeArgs 1 2 3 = 6)
-  do test "wdfjcdwkj7" (Point.ThreePatternArgs [1] [2] [3] = 6)
-  let p2 = (new Point(16)) 
-  do test "wdfjcdwkj4" (p2.InstanceTwoArgs 1 2 = 16 + 3)
-  do test "wdfjcdwkj5" (p2.InstanceTwoPatternArgs [1] [2] = 16 + 3)
-  do test "wdfjcdwkj6" (p2.InstanceThreeArgs 1 2 3 = 16 + 6)
-  do test "wdfjcdwkj7" (p2.InstanceThreePatternArgs [1] [2] [3] = 16 + 6)
-
-end
-
-
-//---------------------------------------------------------------------
-// Test we can implement a debug view
-
-
-
-
-type 
-  [<DebuggerTypeProxy(typeof<MyIntListDebugView>) >]
-   MyIntList = MyNil | MyCons of int * MyIntList
-
-and MyIntListDebugView =
-   class 
-     val v: MyIntList
-     new(x) = { v = x }     
-     [<DebuggerBrowsable(DebuggerBrowsableState.RootHidden)>] 
-     member x.Items = 
-        let rec length x acc = match x with MyNil -> acc | MyCons(a,b) -> length b (acc+1) 
-        let len = length x.v 0 
-        let items = Array.zeroCreate len 
-        let rec go n l = match l with MyNil -> () | MyCons(a,b) -> items.[n] <- a; go (n+1) b 
-        go 0 x.v;
-        items
-   end
-
-
-//---------------------------------------------------------------------
-// Pattern matching on objects
-
-module PatternMatchTests = begin
-    type P = 
-      class 
-        val x1: int; 
-        val x2: string; 
-        new(a,b) = {x1=a; x2=b } 
-      end
-    let p = new P(3,"34")
-end
-
-
-//---------------------------------------------------------------------
-// 'then' on construction
-
-module ThenDoTest = begin
-    let res = ref 2
-    type P = 
-      class 
-        val x1: int; val x2: string; 
-        new(a,b) = {x1=a; x2=(test "ewqonce1" (!res = 2); b) } then res := !res + 1 
-      end
-
-    do ignore(new P(3,"5"))
-    do test "ewqonce2" (!res = 3)
-
-end
-
-//---------------------------------------------------------------------
-// 'then' on construction recursive reference
-
-module ThenDoTest2 = begin
-    let res = ref 2
-    type P = 
-      class 
-        val x1: int; val x2: string; 
-        new(a,b) as x = 
-           { x1= !res; 
-             x2=(test "ewqonce3" (!res = 2); b) } 
-           then 
-              test "ewqonce4" (!res = 2);
-              res := !res + 1; 
-              test "ewqonce5" (!res = 3);
-              test "ewqonce6" (x.x1 = 2) 
-      end
-
-    do ignore(new P(3,"5"))
-    do test "ewqonce7" (!res = 3)
-
-end
-
-module GenericInterfaceTest = begin
-
-    type Foo<'a> =
-      interface 
-          abstract fun1 : 'a -> 'a
-          abstract fun2 : int -> int
-      end
-
-
-    type Bar<'b> =
-      class 
-          val store : 'b
-          interface Foo<'b> with
-            member self.fun1(x) = x
-            member self.fun2(x) = 1
-          end
-          new(x) = { store = x }
-      end
-
-
-    type Bar2<'b> =
-      class 
-          val store : 'b
-          interface Foo<'b> with
-            member self.fun1(x:'b) = x
-            member self.fun2(x) = 1
-          end
-          new(x) = { store = x }
-      end
-
-    type Bar3<'b> =
-      class 
-          val store : int
-          interface Foo<'b> with
-            member self.fun1(x) = x
-            member self.fun2(x) = 1
-          end
-          new(x) = { store = x }
-      end
-
-end
-
-
-//---------------------------------------------------------------------
-//
-  
-
-
-module Inventory = begin
-
-    type item = A | B
-    type image = A | B
-
-    type ItemDetails = 
-      { ItemIndex: item;
-        InventoryImage: image;
-        Name : string }
-
-    type IInventory = interface
-     abstract Contains : item -> bool
-     abstract Remove : item -> unit
-     abstract GetDetails : item -> ItemDetails  
-     abstract Add : ItemDetails -> unit  
-     abstract GetTuple : unit -> (item * image * string) list 
-     end
-
-    module List = 
-        let indexNotFound() = raise (new System.Collections.Generic.KeyNotFoundException("An index satisfying the predicate was not found in the collection"))
-
-        let rec assoc x l = 
-            match l with 
-            | [] -> indexNotFound()
-            | ((h,r)::t) -> if x = h then r else assoc x t
-        let rec remove_assoc x l = 
-            match l with 
-            | [] -> []
-            | (((h,_) as p) ::t) -> if x = h then t else p:: remove_assoc x t
-
-
-
-    type Inventory = class
-      val inv : ItemDetails list ref
-      new() = { inv = ref [] }
-      interface IInventory with
-       member this.Contains i = try (List.assoc i (List.map (fun itd -> (itd.ItemIndex, true)) !this.inv)) with :? System.Collections.Generic.KeyNotFoundException -> false
-       member this.Remove i = this.inv := List.map snd (List.remove_assoc i (List.map (fun itd -> (itd.ItemIndex, itd)) !this.inv))
-       member this.GetDetails i = List.assoc i (List.map (fun itd -> (itd.ItemIndex, itd)) !this.inv)
-       member this.Add itd = if ((this :> IInventory).Contains (itd.ItemIndex) = false) then this.inv := itd :: !this.inv
-       member this.GetTuple() =
-          List.map (fun itd -> (itd.ItemIndex,itd.InventoryImage,itd.Name)) !this.inv
-      end
-    end
-
-end
-
-//---------------------------------------------------------------------
-// Another interface test
-
-module SamplerTest = begin
-
-    type Sampler<'a,'b> = 
-      interface
-        abstract Sample : 'a -> unit 
-        abstract GetStatistic : unit -> 'b
-      end
-      
-(*
-    let NewAverage(toFloat) = 
-      let count = ref 0
-      let total = ref 0.0 
-      { new Sampler<_,float>
-          member self.Sample(x) = incr count; total := !total + toFloat x
-          member self.GetStatistic() = !total / float(!count) }
-
-*)
-    let NewAverage(toFloat) = 
-      let count = ref 0
-      let total = ref 0.0 
-      { new Sampler<_,float> with
-          member __.Sample(x) = incr count; total := !total + toFloat x
-          member __.GetStatistic() = !total / float(!count) }
-
-    type Average<'a> = 
-      class
-        val mutable total : float
-        val mutable count : int
-        val toFloat : 'a -> float
-        new(toFloat) = {total = 0.0; count =0; toFloat = toFloat }
-        interface Sampler< 'a,float > with
-          member this.Sample(x) = this.count <- this.count + 1; this.total <- this.total + this.toFloat x
-          member this.GetStatistic() = this.total / float(this.count)
-        end
-      end
-
-end
-
-
-//---------------------------------------------------------------------
-// This simple case of forward-reference revealed a bug
-
-type callconv = AA
-  with 
-        member x.IsInstance         = x.ThisConv 
-        member x.ThisConv           = 1
-  end 
-
-// Likewise
-
-module OverloadZeroOneTestSoohyoung = begin
-
-    type Point =
-      class
-        val mutable mx: int
-        
-        new () = { mx = 0 }
-        new (ix) = { mx = ix }
-      end
-
-end
-
-//---------------------------------------------------------------------
-// Bad error message case 
-
-
-module Ralf = begin 
- 
-  type Matrix = M  | N
-
-  [<AbstractClass>]
-  type Distribution = 
-      class 
-        new () = { }
-
-        abstract member NumberOfDimensions : unit -> int
-        abstract member Sample: int -> System.Random -> Matrix
-        abstract member Density: Matrix -> float
-        abstract member CloneConstant: unit -> Distribution
-        abstract member Clone: unit -> Distribution
-        abstract member AbsoluteDifference: Distribution -> float
-
-      end
-
-  type Gaussian1D =
-      class 
-            inherit Distribution
-            val PrecisionMean : float
-            val Precision : float
-            new (precisionMean, precision) = { PrecisionMean = 0.0; Precision = 0.0 }
-            override x.NumberOfDimensions() = 1
-            override x.Density point = 1.0 
-            override x.AbsoluteDifference distribution = 0.0
-            override x.Clone() = new Gaussian1D (0.0,0.0) :> Distribution
-            override x.CloneConstant() = new Gaussian1D (x.PrecisionMean,x.Precision) :> Distribution
-            override x.Sample numberOfSamples random = failwith "" // new Matrix (numberOfSamples,x.NumberOfDimensions)
-      end
-
-end
-
-//---------------------------------------------------------------------
-// A random bunch of overloaded operator tests
-
-module MultipleOverloadedOperatorTests = begin
-
-    let f1 (x:DateTime) (y:TimeSpan) : DateTime = x - y
-    let g1 (x:DateTime) (y:DateTime) : TimeSpan = x - y
-    // Return type is also sufficient:
-    let f2 (x:DateTime) y : DateTime = x - y
-    let g2 (x:DateTime) y : TimeSpan = x - y
-    // Just argument types are also sufficient:
-    let f3 (x:DateTime) (y:TimeSpan)  = x - y
-    let g3 (x:DateTime) (y:DateTime)  = x - y
-end
-
-
-//---------------------------------------------------------------------
-// A random bunch of overloaded operator tests
-
-module OverloadedOperatorTests = begin
-
-
-    let x = []
-    do printf "len = %d\n" x.Length
-    let c = ("abc").[2]
-
-    let arr = [| 1 |]
-    do printf "len = %d\n" x.Length
-    let elem = arr.[0]
-    let _ = arr.[0] <- 3
-
-    let SCAL = new System.Collections.ArrayList()
-    let _ = SCAL.Add(3)
-    let _ = SCAL.[0]
-    let _ = SCAL.[0] <- box 4
-
-    let SCGL = new System.Collections.Generic.List<int>()
-    let _ = SCGL.Add(3)
-    let _ = SCGL.[0]
-    let _ = SCGL.[0] <- 3
-
-    let f (x: 'a) = 
-      let SCGL = new System.Collections.Generic.List<'a>() 
-      let _ = SCGL.Add(x) 
-      let _ = SCGL.[0] 
-      let _ = SCGL.[0] <- x 
-      ()
-
-    // check we have generalized 
-    do f 1
-    do f "3"
-
-    let SCGD = new System.Collections.Generic.Dictionary<string,float>()
-    let _ = SCGD.Add("hello",3.0)
-    let _ = SCGD.["hello"]
-
-    let g (k: 'a) (v:'b)= 
-      let SCGD = new System.Collections.Generic.Dictionary<'a,'b>() 
-      let _ = SCGD.Add(k,v)
-      let _ = SCGD.[k]
-      let _ = SCGD.[k] <- v
-      ()
-
-
-
-    // check we have generalized 
-    do g 1 "3"
-    do g "3" 1
-    do g "3" "1"
-    do g 1 1
-
-    let h (v:'b)= 
-      let arr = [| v;v;v |] 
-      let elem = arr.[0] 
-      let _ = arr.[0] <- v 
-      ()
-
-
-    // check we have generalized 
-    do h 1
-    do h "3"
-
-end
-
-module PropertyOverrideTests = begin
-
-    [<AbstractClass>]
-    type A = class
-      abstract S1 :  float with set
-      abstract S2 : string-> float with set
-      abstract S3 : string * string -> float with set
-      abstract G1 :  float with get
-      abstract G2 : string-> float with get
-      abstract G3 : string * string -> float with get
-    end
-     
-    type IA = interface
-      abstract S1 :  float with set
-      abstract S2 : string-> float with set
-      abstract S3 : string * string -> float with set
-      abstract G1 :  float with get
-      abstract G2 : string-> float with get
-      abstract G3 : string * string -> float with get
-    end
-     
-
-
-    type CTest = 
-      class
-        inherit A
-        override x.S1 with  set v = () 
-        override x.S2 with  set s v = () 
-        override x.S3 with  set (s1,s2) v = () 
-        override x.G1 with  get () = 1.0
-        override x.G2 with  get (s:string) = 2.0
-        override x.G3 with  get (s1,s2) = 3.0
-        interface IA with 
-          override x.S1 with  set v = () 
-          override x.S2 with  set s v = () 
-          override x.S3 with  set (s1,s2) v = () 
-          override x.G1 with  get () = 1.0
-          override x.G2 with  get (s:string) = 2.0
-          override x.G3 with  get (s1,s2) = 3.0
-        end
-
-      end
-
-end
-
-module FieldsInClassesDontContributeToRecordFieldInference = begin
-
-  type container = class
-      val capacity : float
-      new(cap) = { capacity = cap } 
-  end
-
-  type cargo = class
-      val capacity : float  // (Error does not appear when the name is changed to capacity1)
-      new(cap) = { capacity = cap }
-  end
-
-  let total_capacity cl = List.fold(fun sum (z:container) -> z.capacity + sum) 0.0 cl
-
-  let cap = total_capacity [ new container(100.0); new container(50.0)]
-
-end
-
-module LucianRecords1 = begin
-  type MyRecord1 = {a:int; x:int}
-  type MyRecord2 = {a:int; y:string}
-  let f (m:MyRecord1) : MyRecord1 = {m with a=3} 
-  let g (m:MyRecord2) : MyRecord2 = {m with a=3} 
-  let h (m:MyRecord1) = m.a
-
-  type Tab = {a:string; b:string}
-  type Tac = {a:string; c:string}
-  type Test = Cab of Tab | Cac of Tac
-  let a = Cab( {a="hello"; b="world";} )
-
-end
-
-module DefaultConstructorConstraints = begin
-
-  let f1 () : 'a when 'a : (new : unit -> 'a) = new 'a()
-  let x1 = (f1() : obj)
-  let x2 = (f1() : int)
-  let x3 = (f1() : DateTime)
-  let x4 = (f1() : System.Windows.Forms.Form)
-  let f2 () = f1()
-  let y1 = (f2() : obj)
-  let y2 = (f2() : int)
-  let y3 = (f2() : DateTime)
-  let y4 = (f2() : System.Windows.Forms.Form)
-  
-end
-
-module AccessBugOnFSharpList = begin
-
-    open System.Web
-    open System.Web.Hosting
-    open System.Data.SqlClient
-
-    type TopicPathProvider = 
-                     class
-                                     inherit VirtualPathProvider 
-                                     
-                                     new() = { inherit VirtualPathProvider(); }                          
-                                                      
-                                     member x.TopicExists topic =
-                                                      let cmd = new SqlCommand()
-                                                      cmd.CommandText <- "SELECT COUNT(*) FROM Topic WHERE Topic.Name = @name";
-                                                      (cmd.Parameters.Add("@name", System.Data.SqlDbType.NVarChar, 255)).Value <- topic;
-                                                      unbox(cmd.ExecuteScalar()) > 0
-                                     
-                                     override x.FileExists((virtualPath: string)) =
-                                                      let relPath = VirtualPathUtility.ToAppRelative(virtualPath)
-                                                      if relPath.StartsWith("~/topic") then
-                                                                       x.TopicExists (relPath.Substring(7))
-                                                      else
-                                                                       x.Previous.FileExists(virtualPath)
-                                                                       
-                                     override x.DirectoryExists((virtualDir: string)) =
-                                                      let relPath = VirtualPathUtility.ToAppRelative(virtualDir)
-                                                      relPath.StartsWith("~/topic") || x.DirectoryExists(virtualDir)
-                     end
-
-    let AppInitialize()  = 
-                     let provider = new TopicPathProvider()
-                     HostingEnvironment.RegisterVirtualPathProvider(provider)
-
-end
-
-
-
-module TestConstrainedItemProperty = begin
-    type Foo = 
-        interface 
-          abstract Item : int -> string with get
-        end
-
-    let f1 (x : #Foo) = x.[1]
-
-    let f2 (x : #Foo) = x.[1]
-end
-
-
-module ExplicitSyntacCtor = begin
-
-    type C =
-       class
-           val xx : int
-           new(x,y) = 
-               if y then 
-                  { xx = x}
-               else
-                  { xx = x+x}
-           new(x) = 
-               let six = 3 + 3
-               { xx = x}
-           static member Create() = 
-               let six = 3 + 3
-               new C(3+3)
-           new() = 
-               let six = 3 + 3
-               new C(3+3)
-           new(a,b,c) = new C(a+b+c)
-           new(a,b,c,d) = 
-               new C(a+b+c+d)
-               then
-                 printf "hello"
-       end
-
-
-
-    type C1(x) =
-       class
-           let xx = x + x
-           let f x = x + x
-           let mutable state = x + x + xx
-
-           do printf "hello\n"
-           
-           static member Create() = 
-               let six = 3 + 3
-               new C(3+3)
-
-           new(x,y) = new C1(x+y)
-                      
-           member self.Increment = state <- state + 1
-           member self.Once= xx 
-           member self.Twice = xx + xx
-       end
-
-    let createRemoteAppDomain<'T> (d: AppDomain) = 
-        unbox<'T>(d.CreateInstanceAndUnwrap(typeof<'T>.Assembly.FullName,typeof<'T>.FullName))
-
-
-    // This is the simple version
-    let rec maxList x =
-      match x with 
-      | [] -> failwith "no elements"
-      | [h] -> h
-      | h::t -> max h (maxList t)
-
-    // This is how you use an accumulating parameter
-
-    let rec maxListAcc acc x =
-      match x with 
-      | [] -> acc
-      | [h] -> max acc h
-      | h::t -> maxListAcc (max acc h) t
-
-    let maxList2 x =
-      match x with 
-      | [] -> failwith "no elements"
-      | h::t -> maxListAcc h t
-
-    type ICool =
-        interface
-            abstract tst : unit->bool 
-        end    
-        
-    [<AbstractClass>]
-    type Cool() = 
-        class
-            abstract tst : unit -> bool
-            interface ICool with
-                member this.tst () = true
-            end  
-        end
-        
-    type beCool() =
-        class 
-            inherit Cool()
-            override this.tst() = false
-            interface ICool with
-                member this.tst () = (this : beCool).tst()
-            end  
-        end
-
-end
-
-module Ex11 = 
-    type MutableVector2D(dx:float,dy:float) =
-        let mutable currDX = dx
-        let mutable currDY = dy
-
-        member this.DX with get() = currDX and set(v) = currDX <- v
-        member this.DY with get() = currDY and set(v) = currDY <- v
-
-        member v.Length 
-             with get () = sqrt(currDX*currDX+currDY*currDY)
-             and  set len = 
-                 let theta = v.Angle
-                 currDX <- cos(theta)*len;
-                 currDY <- sin(theta)*len
-
-        member c.Angle 
-             with get () = atan2 currDY currDX
-             and  set theta = 
-                 let len = c.Length
-                 currDX <- cos(theta)*len;
-                 currDY <- sin(theta)*len
-
-    let v1 = MutableVector2D(3.0,4.0)
-    v1.Length
-    v1.Angle
-    v1.Angle <- System.Math.PI / 6.0 // = 30 degrees
-    v1.Length
-    v1.DX, v1.DY
-
-    v1.DY / v1.Length
-
-    type Vector2D(dx: float, dy: float) =
-        let length = sqrt(dx * dx + dy * dy)
-        member v.DX = dx
-        member v.DY = dy
-        member v.Length = length
-        member v.Scale(k)    = Vector2D(k*dx,   k*dy)
-        member v.ShiftX(dx') = Vector2D(dx=dx+dx', dy=dy)
-        member v.ShiftY(dy') = Vector2D(dx=dx,     dy=dy+dy')
-        static member Zero = Vector2D(dx=0.0, dy=0.0)
-        static member OneX = Vector2D(dx=1.0, dy=0.0)
-        static member OneY = Vector2D(dx=0.0, dy=1.0)
-
-    type SparseVector  (items: seq<int * float>)= 
-        let elems = new System.Collections.Generic.SortedDictionary<_,_>() 
-        do items |> Seq.iter (fun (k,v) -> elems.Add(k,v))
-        member t.Item 
-            with get i = 
-                if elems.ContainsKey(i) then elems.[i]
-                else 0.0
-
-    type UnitVector2D(dx,dy) = 
-          let tolerance = 0.000001
-          let len = sqrt(dx * dx + dy * dy)
-          do if abs(len - 1.0) >= tolerance then failwith "not a unit vector";
-          member v.DX = dx
-          member v.DY = dy
-
-module Ex11b = 
-    type Vector2D (dx:float,dy:float) =
-        member x.DX = dx
-        member x.DY = dy
-        static member (+) ((v1:Vector2D),(v2:Vector2D)) = 
-            Vector2D(v1.DX + v2.DX, v1.DY + v2.DY)
-        static member (-) ((v1:Vector2D),(v2:Vector2D)) =
-            Vector2D(v1.DX - v2.DX, v1.DY - v2.DY)
-
-    let v1 = Vector2D(3.0,4.0)
-    v1
-    v1 + v1
-    v1 - v1
-
-
-module Ex11c = 
-    type Vector2D (dx:float,dy:float) =
-        member x.DX = dx
-        member x.DY = dy
-        static member Create(? dx: float, ?dy:float) = 
-            let dx = match dx with None -> 0.0 | Some v -> v
-            let dy = match dy with None -> 0.0 | Some v -> v
-            Vector2D(dx,dy)
-
-module T1 = 
-    type Vector2D(dx: float, dy: float) =
-        let len = sqrt(dx * dx + dy * dy)
-        member v.DX = dx
-        member v.DY = dy
-        member v.Length = len
-
-    Vector2D(1.0,1.0) = Vector2D(1.0,1.0)
-
-module Ex5 = 
-    open System.Drawing
-    type Label(?text,?font) =
-        let text = match text with None -> "" | Some v -> v
-        let font = match font with None -> new Font(FontFamily.GenericSansSerif,12.0f) | Some v -> v
-        member x.Text = text
-        member x.Font = font
-
-    Label(text="Hello World")
-    Label(font=new Font(FontFamily.GenericMonospace,36.0f),
-          text="Hello World")
-
-module Ex6 = 
-    type IShape =
-        abstract Contains : Point -> bool
-        abstract BoundingBox : Rectangle
-
-    and Vector = 
-        { DX:float; DY:float }
-        member v.Length = sqrt(v.DX*v.DX+v.DY*v.DY)
-        static member (+) (v1:Vector,v2:Vector) = { DX=v1.DX+v2.DX; DY=v1.DY+v2.DY }
-        static member (-) (v1:Vector,v2:Vector) = { DX=v1.DX-v2.DX; DY=v1.DY-v2.DY }
-          
-    and Point = 
-        { X:float; Y:float }
-
-        static member (-) (p1:Point,p2:Point) = { DX=p1.X-p2.X; DY=p1.Y-p2.Y }
-
-        static member (-) (p:Point,v:Vector) = { X=p.X-v.DX; Y=p.Y-v.DY }
-          
-        static member (+) (p:Point,v:Vector) = { X=p.X+v.DX; Y=p.Y+v.DY }
-          
-    and Rectangle = 
-        {X1:float; Y1:float; X2:float; Y2:float}
-        static member Create(p1:Point,p2:Point) =
-            {X1=p1.X; Y1=p1.Y; X2=p2.X; Y2=p2.Y }
-
-
-    let circle(center:Point,radius:float) = 
-        { new IShape with
-              member x.Contains(p:Point) = (p - center).Length < radius
-              member x.BoundingBox =
-                  let diag = {DX=radius;DY=radius}
-                  Rectangle.Create(center-diag,center+diag) }
-    
-
-    let square(center:Point,side:float) = 
-        { new IShape with
-              member x.Contains(p:Point) = 
-                  let v = (p - center) 
-                  abs(v.DX) < side/2.0 && abs(v.DY) < side/2.0
-              member x.BoundingBox =
-                  let diag = {DX=side/2.0;DY=side/2.0}
-                  Rectangle.Create(center-diag,center+diag) }
-
-    type MovingSquare() = 
-        let mutable center = {X=0.0;Y=0.0}
-        let mutable side = 1.0
-        member sq.Center with get() = center and set(v) = center <- v
-        member sq.SideLength with get() = side and set(v) = side <- v
-        interface IShape with
-              member x.Contains(p:Point) = 
-                  let v = (p - center) 
-                  abs(v.DX) < side/2.0 && abs(v.DY) < side/2.0
-              member x.BoundingBox =
-                  let diag = {DX=side/2.0;DY=side/2.0}
-                  Rectangle.Create(center-diag,center+diag) 
-    
-module Ex7 = 
-    open System.Drawing
-    type IShape =
-        abstract Contains : Point -> bool
-        abstract BoundingBox : Rectangle
-
-    let circle(center:Point,radius:int) = 
-        { new IShape with
-              member x.Contains(p:Point) = 
-                  let dx = float32 (p.X - center.X)
-                  let dy = float32 (p.Y - center.Y)
-                  sqrt(dx*dx+dy*dy) < float32 radius
-              member x.BoundingBox =
-                  Rectangle(center.X-radius,center.Y-radius,2*radius,2*radius) }
-    
-
-    let bigCircle = circle(Point(0,0), 100)
-
-    bigCircle.BoundingBox    
-    bigCircle.Contains(Point(70,70))
-    bigCircle.Contains(Point(71,71))
-        
-    let square(center:Point,side:int) = 
-        { new IShape with
-              member x.Contains(p:Point) = 
-                  let dx = p.X - center.X
-                  let dy = p.Y - center.Y
-                  abs(dx) < side/2 && abs(dy) < side/2
-              member x.BoundingBox =
-                  Rectangle(center.X-side,center.Y-side,side*2,side*2) }
-
-    type MovingSquare() = 
-        let mutable center = Point(x=0,y=0)
-        let mutable side = 10
-        member sq.Center with get() = center and set(v) = center <- v
-        member sq.SideLength with get() = side and set(v) = side <- v
-        interface IShape with
-              member x.Contains(p:Point) = 
-                  let dx = p.X - center.X
-                  let dy = p.Y - center.Y
-                  abs(dx) < side/2 && abs(dy) < side/2
-              member x.BoundingBox =
-                  Rectangle(center.X-side,center.Y-side,side*2,side*2) 
-
-
-module MoreOptionalArgTests = 
-    open System
-    open System.Text
-    open System.Collections.Generic
-
-
-    let defaultArg x y = match x with None -> y | Some v -> v
-
-    type T() = 
-        static member OneNormalTwoOptional (arg1, ?arg2, ?arg3) = 
-            let arg2 = defaultArg arg2 3
-            let arg3 = defaultArg arg3 10
-            arg1 + arg2 + arg3
-
-        static member TwoOptional (?arg1, ?arg2) = 
-            let arg1 = defaultArg arg1 3
-            let arg2 = defaultArg arg2 10
-            arg1 + arg2 
-
-
-    test "optional arg test" (16 = T.OneNormalTwoOptional(3))
-    test "optional arg test" (15 = T.OneNormalTwoOptional(3,2))
-    test "optional arg test" (16 = T.OneNormalTwoOptional(arg1=3))
-    test "optional arg test" (14 = T.OneNormalTwoOptional(arg1=3,arg2=1))
-    test "optional arg test" (13 = T.OneNormalTwoOptional(arg2=3,arg1=0))
-    test "optional arg test" (14 = T.OneNormalTwoOptional(arg2=3,arg1=0,arg3=11))
-    test "optional arg test" (14 = T.OneNormalTwoOptional(0,3,11))
-    test "optional arg test" (14 = T.OneNormalTwoOptional(0,3,arg3=11))
-
-    test "optional arg test" (16 = T.OneNormalTwoOptional(arg1=3))
-    test "optional arg test" (14 = T.OneNormalTwoOptional(arg1=3,?arg2=Some(1)))
-    test "optional arg test" (14 = T.OneNormalTwoOptional(arg2=3,arg1=0,arg3=11))
-    test "optional arg test" (14 = T.OneNormalTwoOptional(?arg2=Some(3),arg1=0,arg3=11))
-    test "optional arg test" (14 = T.OneNormalTwoOptional(0,3,?arg3=Some(11)))
-
-
-    test "optional arg test" (13 = T.TwoOptional())
-    test "optional arg test" (12 = T.TwoOptional(2))
-    test "optional arg test" (11 = T.TwoOptional(arg1=1))
-    test "optional arg test" (13 = T.TwoOptional(arg1=3))
-    test "optional arg test" (14 = T.TwoOptional(arg1=3,arg2=11))
-    test "optional arg test" (14 = T.TwoOptional(3,11))
-    test "optional arg test" (14 = T.TwoOptional(3,arg2=11))
-    do printfn "Done MoreOptionalArgTests"
-
-
-module MoreRandomTests = 
-    do printfn "MoreRandomTests"
-
-    let memoize f = 
-        let cache = ref Map.empty
-        fun x -> 
-            match (!cache).TryFind(x) with
-            | Some res -> res
-            | None -> 
-                 let res = f x
-                 cache := (!cache).Add(x,res)
-                 res
-
-
-
-    // Save computed results by using an internal dictionary.
-    // Note that memoize is inferred to have type
-    //   ('a -> 'b) -> ('a -> 'b)
-    let memoize2 f = 
-        let cache = System.Collections.Generic.Dictionary<_, _>()
-        fun x -> 
-            let ok,res = cache.TryGetValue(x)
-            if ok then res 
-            else let res = f x
-                 cache.[x] <- res
-                 res
-
-
-module MemberTakingOptionalArgumentUsedAsFirstClassFunctionValue = 
-    type C() = 
-        static member M(?a:int) = a
-
-    let pf = (C.M, C.M)
-
-    fst pf ()
-    snd pf ()
-
-module StillMoreRandomTests = 
-    do printfn "StillMoreRandomTests"
-
-    type Var = string
-
-    type ArithExpr = 
-      | Sum of ArithExpr * ArithExpr
-      | Mul of ArithExpr * ArithExpr
-      | Neg of ArithExpr
-      | Var of Var
-      | Let of Var * ArithExpr * ArithExpr
-
-
-    type Circuit = 
-      | And of Circuit * Circuit
-      | Not of Circuit
-      | True
-      | Var of Var
-      | Exists of Var * Circuit
-
-    let False = Not(True)
-    let Forall(v,p) = Not(Exists(v,Not(p)))
-    let Or (p1,p2) = Not(And(Not(p1),Not(p2)))
-
-    // nice infix notation, also deerived equality and implication
-    let (&&&) p1 p2 = And(p1,p2)
-    let (|||) p1 p2 = Or(p1,p2)
-    let (===) p1 p2 = (p1 &&& p2) ||| (Not(p1) &&& Not(p2))
-    let (==>) p1 p2 = (Not(p1) ||| p2) 
-    let Cond p1 p2 p3 = (p1 ==> p2) &&& (Not(p1) ==> p3)
-
-
-    type Env = Map<Var,bool>
-
-    let rec eval (env:Env) p = 
-        match p with
-        | And(p1,p2) -> eval env p1 && eval env p2
-        | Not(p1) -> not (eval env p1)
-        | Var(v) ->  env.[v]
-        | True ->  true
-        | Exists(v,p) ->  
-            // Evaluate p with the variable 'true'
-            eval (env.Add(v,true))  p ||
-            // Evaluate p with the variable 'false'
-            eval (env.Add(v,false)) p
-
-
-    eval Map.empty True
-
-    let varCount = ref 0 
-    let freshVariable() = incr varCount; (!varCount).ToString()
-
-    let hide1 g = 
-        let stateVar = freshVariable()
-        let state = Var(stateVar)
-        Exists(stateVar, g(state))
-
-    //let circuit inp out = hide1 (fun state -> state === (state &&& inp) &&& out === state)
-    //let circuit2 inp out = hide1 (fun inner -> circuit inp inner &&& circuit inner out)
-
-    /// Helper to generate a variable and generate a circuit that
-    /// uses the variable.
-    let forall1 g = 
-        let v1 = freshVariable()
-        Forall(v1,g(Var(v1)))
-
-    /// Same for three variables
-    let forall3 g = forall1 (fun v1 -> forall1 (fun v2 -> forall1 (fun v3 -> g v1 v2 v3)))
-
-    // This is the circuit: it chooses the output based on the input
-    // The circuit looks at input 0, and chooses the ouput to be input 1 or input 2
-    let circuit (inp : Circuit[]) out = 
-        Cond inp.[0] (out === inp.[1]) (out === inp.[2])
-
-    /// This is a specification of one property of the circuit. It says 
-    /// that if input 1 is the same as input 2 then the result is
-    /// this input, regardless of the values of the inputs 
-    let check1 = forall3 (fun inp0 inp1 out -> circuit [| inp0;inp1;inp1 |] out ==> (out === inp1))
-
-    eval Map.empty check1 // 'true' - the property holds
-
-    eval Map.empty (Cond True False False) = false
-    eval Map.empty (Cond True False True) = false
-    eval Map.empty (Cond True True False) = true
-    eval Map.empty (Cond False True False) = false
-    eval Map.empty (Cond False False True) = true
-    eval Map.empty (False === True) = false
-    eval Map.empty (False === False) = true
-    eval Map.empty (True === True) = true
-    eval Map.empty (True === False) = false
-    eval Map.empty (Forall("a",Var("a") === Var("a"))) = true
-    eval Map.empty (Forall("a",Var("a") ==> Var("a"))) = true
-    eval Map.empty (Forall("a",Not(Var("a") === Var("a")))) = false
-    eval Map.empty (Forall("a",Forall("b",Var("a") === Var("b")))) = true
-
-module MemoizeSample = 
-    do printfn "MemoizeSample"
-
-    type Function<'a,'b> = interface
-        abstract Item : 'a -> 'b with get
-        abstract Clear : unit -> unit
-    end
-    
-    let memoize f = 
-        let lookasideTable = new System.Collections.Generic.Dictionary<_,_>()
-        { new Function<_,_> with 
-              member t.Item
-                 with get(n) = 
-                     if lookasideTable.ContainsKey(n) then lookasideTable.[n]
-                     else let res = f n
-                          lookasideTable.Add(n,res)
-                          res 
-              member t.Clear() = 
-                  lookasideTable.Clear() }
-                  
-
-    let rec fibFast = memoize (fun n -> if n <= 2 then 1 else fibFast.[n-1] + fibFast.[n-2])
-
-    fibFast.[3]
-    fibFast.[30]
-    fibFast.Clear()
-    
-(*
-module NameLookupServiceExample = 
-    do printfn "NameLookupServiceExample"
-    type NameLookupService = 
-        abstract Contains : string -> bool
-        abstract ClosestPrefixMatch : string -> string 
-
-    let simpleNameLookup (words: string list) = 
-        let wordTable = Set.ofSeq(words)
-        let score (w1:string) (w2:string) = 
-            let lim = (min w1.Length w2.Length) 
-            let rec loop i acc =  
-                if i >= lim then acc 
-                else loop (i+1) (Char.code w1.[i] - Char.code w2.[i] + acc)
-            loop 0 0
-            
-        { new NameLookupService with
-            member t.Contains(w) = wordTable.Contains(w)
-            member t.ClosestPrefixMatch(w) = 
-                if wordTable.Contains(w) then w
-                else
-                    printfn "w = %s" w
-                    let above = 
-                        match wordTable.GetNextElement(w) with
-                        | Some w2 when w2.StartsWith(w) -> Some w2
-                        | _ -> None
-                    let below = 
-                        match wordTable.GetPreviousElement(w) with
-                        | Some w2 when w2.StartsWith(w) -> Some w2
-                        | _ -> None
-                    printfn "above = %A, below = %A" above below
-                    match above, below with
-                    | Some w1,Some w2 -> if score w w1 > score w w2 then w2 else w1
-                    | Some res,None 
-                    | None,Some res -> res
-                    | None,None -> failwith "no match!" }
-
-
-    let capitalLookup = simpleNameLookup ["London";"Paris";"Warsaw";"Tokyo"]
-
-    capitalLookup.Contains "Paris"
-    capitalLookup.ClosestPrefixMatch "Wars"
-
-*)
-
-
-module ConstraintsInMembers = begin
-
-    type IDuplex = 
-      interface 
-      end
-
-    type IServer = 
-      interface 
-      end
-      
-    let bind (a:#IServer) = "2"
-
-    let Bind1(v:#IDuplex) : string = bind v 
-
-    type C() = 
-        member x.Bind1(v:#IDuplex) : string = bind v 
-        member x.Bind2(v:#IDuplex) : string = bind v 
-end
-
-module DelegateByrefCreation = begin
-    type D = delegate of int byref -> int
-    type D2 = delegate of int byref * int byref -> int
-
-    let createImmediateDelegate = new D(fun b -> b)
-    let createImmediateDelegate2 = new D2(fun b1 b2 -> b1  + b2)
-end
-
-module InterfaceCastingTests = begin
-
-    type IBar = 
-        interface
-        end
-
-    type IFoo = 
-        interface
-        end
-
-    type C() = 
-        class
-        end
-
-    type D() = 
-        class
-           interface IFoo 
-        end
-        
-    type Struct = 
-        struct
-           val x : int
-        end
-        
-    type R = 
-        { c : int }
-        
-    type U = 
-        A | B
-        
-        
-    let checkPatternTestInterfaceToInterface(l:IBar list) =
-        match l with
-        | [:? IFoo] -> None
-        | _ -> None
-        
-    let checkPatternTestInterfaceToUnsealedClassImplicit(l:IBar list) =
-        match l with
-        | [:? C] -> None
-        | _ -> None
-        
-    let checkPatternTestInterfaceToUnsealedClassExplicit(l:IBar list) =
-        match l with
-        | [:? D] -> None
-        | _ -> None
-
-
-        
-    let checkTypeTestInterfaceToInterface(l:IBar ) =
-        (l :? IFoo)
-        
-    let checkTypeTestInterfaceToUnsealedClassImplicit(l:IBar) =
-        (l :? C)
-        
-    let checkTypeTestInterfaceToUnsealedClassExplicit(l:IBar) =
-        (l :? D)
-
-    let checkCoercionInterfaceToInterface(l:IBar ) =
-        (l :?> IFoo)
-        
-    let checkCoercionInterfaceToUnsealedClassImplicit(l:IBar) =
-        (l :?> C)
-        
-    let checkCoercionInterfaceToUnsealedClassExplicit(l:IBar) =
-        (l :?> D)
-
-    let checkDowncastInterfaceToInterface(l:IBar ) =
-        (downcast l : IFoo)
-        
-    let checkDowncastInterfaceToUnsealedClassImplicit(l:IBar) =
-        (downcast l : C)
-        
-    let checkDowncastInterfaceToUnsealedClassExplicit(l:IBar) =
-        (downcast l : D)
-
-end
-
-
-module MiscGenericOverrideTest = 
-   do printfn "MiscGenericOverrideTest"
-   type 'a Class2 = 
-      class
-        inherit obj 
-        new () = { inherit obj(); }
-        override this.ToString() = base.ToString() 
-      end
-
-module GlobalTickTock = 
-   //let x = 1
-   do printfn "GlobalTickTock"
-   type TickTock = Tick | Tock
-   type time = float
-   let private x = ref Tick
-   
-  // public module M =
-//      let x = 1
-      
-   //let (private ticked,public TickEvent) = Event.create<TickTock>()
-   //let internal oneTick() = 
-   //    (x := match !x with Tick -> Tock | Tock -> Tick); 
-    //   ticked(!x)
-
-
-module RecursiveInheritanceExampleFromTomas = 
-    type ISome = 
-      interface
-        abstract InterfaceMethod : int -> int
-      end
-    and Test = 
-      class
-        interface ISome with
-          member this.InterfaceMethod  (a) =
-            a + 5
-        end
-      end
-
-
-
-module DefaultImplementationsOfAbstractProperties = 
-    type A() = class
-      abstract Prop : int with set
-      abstract Prop : int with get
-      default x.Prop 
-        with get()  = printf "A::Prop.get"; 6
-        and  set(v) = printf "A::Prop.set(%d)" v
-    end    
-
-module StructDefinition = 
-    type ('h,'t) BUN =
-        struct
-            val head : 'h
-            val tail : 't
-            new(h,t) = {head = h; tail = t}
-        end
-     
-    let heap = Array.init 100 (fun i -> BUN(i,i))
-     
-    let _ = heap.[3]
-
-
-module StructKeywordAsConstraintTest = 
-
-    type Struct1<'a when 'a : struct> =
-        struct
-            val x : int
-        end
-
-    type Struct2<'a when 'a : not struct> =
-        struct
-            val x : int
-        end
-     
-    type Class1<'a when 'a : struct> =
-        class
-            val x : int
-        end
-     
-    type Class2<'a when 'a : not struct> =
-        class
-            val x : int
-        end
-        
-    type Class1b<'a when 'a : struct>(x:int) =
-        member self.X = x
-     
-    type Class2b<'a when 'a : not struct>(x:int) =
-        member self.X = x
-     
-     
-module StaticInitializerTest1 =
-
-    type C<'a>() = 
-        static let mutable v = 2 + 2
-        static do v <- 3
-        
-        member x.P = v
-        static member P2 = v+v
-
-    test "lwnohivw0" ((new C<int>()).P = 3)
-    test "lwnohivw1" ((new C<int>()).P = 3)
-    test "lwnohivw2" ((new C<string>()).P = 3)
-    test "lwnohivw3" ((C<int>.P2) = 6)
-    test "lwnohivw4" ((C<string>.P2) = 6)
-
-module StaticInitializerTest2 =
-
-    type C() = 
-        static let mutable v = 2 + 2
-        static do v <- 3
-        
-        member x.P = v
-        static member P2 = v+v
-
-    check "lwnohivq01" (new C()).P 3
-    check "lwnohivq12" (new C()).P 3
-    check "lwnohivq33" C.P2 6
-    check "lwnohivq44" C.P2 6
-        
-
-module StaticInitializerTest3 =
-
-    let x = ref 2
-    do x := 3
-    
-    type C() = 
-        static let mutable v = x.Value + 1
-        static do v <- 3
-        
-        member x.P = v
-        static member P2 = v+x.Value
-
-    check "lwnohivq05" (new C()).P 3
-    check "lwnohivq16" (new C()).P 3
-    check "lwnohivq37" C.P2 6
-    check "lwnohivq48" C.P2 6
-        
-
-module OkStructTest3 = begin
-    type OkStruct1 = 
-        struct
-            val x : list<OkStruct1>
-        end    
-end
-
-module FSharp_1_0_bug_1748_Problem_Calling_A_Base_Member_A = begin
-
-    type C<'a>(value) =
-        member x.BaseM() = printf "out %d" value
-
-    type D<'b>(value:int) =
-        inherit C<'b>(value) 
-
-        member x.M() = base.BaseM()
-
-end
-
-(*
-module FSharp_1_0_bug_1748_Problem_Calling_A_Base_Member_B = begin
-
-    type Exp<'c when 'c :> Exp<'c>> = abstract Print : unit -> unit
-
-    type PrintLit<'c when 'c :> Exp<'c>>(value) =
-        member x.Value = value
-        member x.BasePrint() = printf "out %d" x.Value
-        interface Exp<'c> with
-            member x.Print() = x.BasePrint()
-
-    type PrintAdd<'c when 'c :> Exp<'c>>(left:'c, right:'c) =
-        member x.Left = left
-        member x.Right = right
-        member x.BasePrint() = x.Left.Print(); printf "+"; x.Right.Print()
-        interface Exp<'c> with
-            member x.Print() = x.BasePrint()
-
-    type EvalExp<'c when 'c :> EvalExp<'c>> =
-        inherit Exp<'c>
-        abstract Eval : unit -> int
-
-    type EvalLit<'c when 'c :> EvalExp<'c>>(value:int) =
-        inherit PrintLit<'c>(value) 
-        member x.BaseEval() = x.Value
-        interface EvalExp<'c> with
-            //the base is not strictly necessary here, but used for clarity
-            member x.Print() = base.BasePrint()
-            member x.Eval() = x.BaseEval()
-
-    type EvalAdd<'c when 'c :> EvalExp<'c>>(left:'c, right:'c) =
-        inherit PrintAdd<'c>(left, right) 
-        member x.BaseEval() = x.Left.Eval() + x.Right.Eval()
-        interface EvalExp<'c> with
-            member x.Print() = base.BasePrint()
-            member x.Eval() = x.BaseEval()
-
-    type EvalExpFix = inherit EvalExp<EvalExpFix>
-
-    type EvalLitFix(value) =
-        inherit EvalLit<EvalExpFix>(value) 
-        interface EvalExpFix with
-            member x.Print() = base.BasePrint()
-            member x.Eval() = base.BaseEval()
-
-    type EvalAddFix(left:EvalExpFix, right:EvalExpFix) =
-        inherit EvalAdd<EvalExpFix>(left, right) 
-        interface EvalExpFix with
-            member x.Print() = base.BasePrint()
-            member x.Eval() = base.BaseEval()
-
-    let e1 = new EvalLitFix(2)
-    let e2 = new EvalLitFix(3)
-    let e3 = new EvalAddFix(e1, e2) :> EvalExpFix
-    do  e3.Print()
-        System.Console.Write(" = " + e3.Eval().ToString())
-end
-*)
-
-
-module Test1 = begin
-    type C() = class end
-
-    type ITest = interface
-                       abstract member Read : #C -> unit
-                     end
-
-    type Impl() = 
-        interface ITest  with
-            override this.Read (orgList : #C) = printfn "done"
-        end
-
-    let impl() = 
-        { new ITest  with
-            override this.Read (orgList : #C) = printfn "done"
-        }
-end
-
-module Test2 = begin
-
-    type C<'a>() = class end
-
-    type ITest<'d> = interface
-                       abstract member Read : #C<'a> -> unit
-                     end
-
-    type Impl() = 
-        interface ITest <int> with
-            override this.Read (orgList : #C<'b>) = printfn "done"
-        end
-
-    let impl() = 
-        { new ITest <int> with
-            override this.Read (orgList : #C<'b>) = printfn "done"
-        }
-
-end
-
-
-module Test3 = begin
-
-    type C<'a>() = class end
-
-    type ITest<'d> = interface
-                       abstract member Read<'b when 'b :> C<'d> > : 'd  -> unit 
-                     end
-
-    type Impl() = 
-        interface ITest <int> with
-            override this.Read<'c when 'c :> C<int> >  _ = printfn "done"
-        end
-
-    let impl() = 
-        { new ITest <int> with
-            override this.Read<'c when 'c :> C<int> >  _ = printfn "done"
-        }
-
-end
-module Test4 = begin
-
-    type C<'a>() = class end
-
-    type ITest<'d> = interface
-                       abstract member Read<'b > : 'b  -> unit 
-                     end
-
-    type Impl() = 
-        interface ITest <int> with
-            override this.Read _ = printfn "done"
-        end
-
-    let impl() = 
-        { new ITest <int> with
-            override this.Read _ = printfn "done"
-        }
-
-end
-
-module Test5 = begin
-
-    type ITest = interface
-                       abstract member Read<'b > : int  -> unit 
-                 end
-
-    type Impl() = 
-        interface ITest with
-            override this.Read _ = printfn "done"
-        end
-
-    let impl() = 
-        { new ITest with
-            override this.Read _ = printfn "done"
-        }
-
-end
-
-module Test6 = begin
-
-
-    type ITest<'d> = interface
-                       abstract member Read : int -> unit
-                     end
-
-    type Impl<'e>() = 
-        interface ITest <'e> with
-            override this.Read (orgList : int) = printfn "done"
-        end
-
-    let impl<'e>() = 
-        { new ITest <'e> with
-            override this.Read (orgList : int) = printfn "done"
-        }
-
-end
-
-
-module Test7 = begin
-
-    type ITest<'d> = interface
-                       abstract member Read : 'd -> unit
-                     end
-
-    type Impl<'e>() = 
-        interface ITest <'e> with
-            override this.Read (orgList : 'e) = printfn "done"
-        end
-
-    let impl() = 
-        { new ITest <'e> with
-            override this.Read (orgList : 'e) = printfn "done"
-        }
-
-end
-
-
-
-module Test8 = begin
-
-    type C<'a>() = class end
-
-    type ITest<'q> = interface
-                       abstract member Read : #C<'q> -> unit
-                     end
-
-    type Impl<'f>() = 
-        interface ITest <'f> with
-            override this.Read (orgList : #C<'f>) = printfn "done"
-        end
-
-    let impl() = 
-        { new ITest <'f> with
-            override this.Read (orgList : #C<'f>) = printfn "done"
-        }
-
-end
-
-
-// FSB 1112, Bug in definition of generic interface
-
-module Test9 = begin
-    open System.Collections.Generic
-
-    type ITest<'T> = interface
-                       abstract member Read : #IList<'T> -> unit
-                     end
-
-    type Impl<'t>() = 
-        interface ITest<'t>  with
-            override this.Read (orgList : #IList<'t>) = printfn "done"
-
-
-    let impl = {new ITest<'t> with
-                     override this.Read orgList = printfn "done"};
-                 
-end
-
-
-module InterfaceEndTokenTests_bugs_FSharp_1_0_1148_and_1431 = 
-    type IFoo = interface
-        abstract Meth3 : unit -> unit
-    end
-
-    type IBar = interface
-        abstract Meth3 : unit -> unit
-    end
-
-
-    type Foo() = class
-        interface IFoo with
-            member this.Meth3 () = ()
-    end
-
-    type Foo1x() = class
-        interface IFoo with
-            member this.Meth3 () = ()
-        end
-    end
-
-    type Foo1b() = 
-        class
-            interface IFoo with
-                member this.Meth3 () = ()
-        end
-
-    type Foo1c() = 
-        class
-            interface IFoo with
-                member this.Meth3 () = ()
-          end
-
-    type Foo1d() = 
-        class
-            interface IFoo with
-                member this.Meth3 () = ()
-                
-         // note the 'end' token doesn't have to align with 'class'
-           end
-
-    type Foo1e() = 
-        class
-            interface IFoo with
-                member this.Meth3 () = ()
-                
-         // note the 'end' token doesn't have to align with 'class'
-      end
-
-    type Foo2() = class
-        interface IFoo with
-            member this.Meth3 () = ()
-        end
-    end
-
-
-    type Foo3() = 
-        interface IFoo with
-            member this.Meth3 () = ()
-        end
-
-    type Foo4() = 
-        interface IFoo with
-            member this.Meth3 () = ()
-        end
-            
-
-    type Foo5() = 
-        interface IFoo with
-            member this.Meth3 () = ()
-            
-    type Foo6() = 
-        interface IFoo with
-            member this.Meth3 () = ()
-        interface IBar with
-            member this.Meth3 () = ()
-            
-            
-    type Foo7() = 
-        interface IFoo with
-            member this.Meth3 () = ()
-        interface IBar with
-            member this.Meth3 () = ()
-        end
-        
-    type Foo7b() = 
-        interface IFoo with
-            member this.Meth3 () = ()
-        end
-        interface IBar with
-            member this.Meth3 () = ()
-        end
-            
-    type Foo8() = 
-        interface IFoo with
-            member this.Meth3 () = ()
-        end
-        interface IBar with
-            member this.Meth3 () = ()
-
-    type Foo9() = 
-        interface IFoo with
-            member this.Meth3 () = ()
-          end
-        interface IBar with
-            member this.Meth3 () = ()
-
-    type Foo10() = 
-        interface IFoo with
-                   member this.Meth3 () = ()
-              end
-          // Spec issue: interfaces and members can progressively indent if 'end' tokens included
-          interface IBar with
-                 member this.Meth3 () = ()
-       
-
-
-type node =
- interface
-   abstract wombat :string
- end
-type nodeB =
- //member it.dummy = "dummy"
- interface node with
-   member it.wombat = "B.wombat"
-
-
-module Check_Static_Let_Bindings_In_Structs = 
-    let r = ref 0 
-    
-    [<Struct>]
-    type S(x:int) = 
-        static let mutable v = 3
-        static do printfn "Initialize S"
-        static do v <- v + 1
-        //do printfn "hello"
-        //do incr r
-        member y.P = x
-        static member V = v
-        
-    do test "vr09jrweokm" (S.V = 3 || S.V = 4)
-    //do test "vr09jrweokm" (!r = 0)
-    let s3 = S(3)
-    let s4 = S(4)
-    do test "vr09jrweokm" (S.V = 4)
-    //do test "vr09jrweokm" (!r = 2)
-
-module UnitArgs = 
-    let f () = 
-       printfn "hello from f"
-       printfn "hello from f"
-       printfn "hello from f"
-       printfn "hello from f"
-       printfn "hello from f"
-       printfn "hello from f"
-       1+2
-
-    let f2 (c:unit) = 
-        printfn "hello  from f2";
-        printfn "hello";
-        printfn "hello";
-        printfn "hello";
-        printfn "hello";
-        printfn "hello";
-        printfn "hello";
-        1+2
-
-    let f3 = fun () -> 
-        printfn "hello  from f3";
-        printfn "hello";
-        printfn "hello";
-        printfn "hello";
-        printfn "hello";
-        printfn "hello";
-        printfn "hello";
-        1+2
-
-    let f4 = function () -> 
-                        printfn "hello  from f4";
-                        printfn "hello";
-                        printfn "hello";
-                        printfn "hello";
-                        printfn "hello";
-                        printfn "hello";
-                        printfn "hello";
-                        1+2
-
-    let f5 = (fun () -> 
-        printfn "hello  from f5";
-        printfn "hello";
-        printfn "hello";
-        printfn "hello";
-        printfn "hello";
-        printfn "hello";
-        printfn "hello";
-        1+2)
-
-
-    type C(x:int) = 
-        static member M() = 
-           printfn "hello from C.M"
-           printfn "hello from C.M"
-           printfn "hello from C.M"
-           printfn "hello from C.M"
-           printfn "hello from C.M"
-           printfn "hello from C.M"
-           1+2
-
-        member x.M2() = 
-           printfn "hello from C.M2"
-           printfn "hello from C.M2"
-           printfn "hello from C.M2"
-           printfn "hello from C.M2"
-           printfn "hello from C.M2"
-           printfn "hello from C.M2"
-           1+2
-        member x.M3 = fun () ->
-           printfn "hello from C.M3"
-           printfn "hello from C.M3"
-           printfn "hello from C.M3"
-           printfn "hello from C.M3"
-           printfn "hello from C.M3"
-           printfn "hello from C.M3"
-           1+2
-        member x.M4 () ()  = 
-           printfn "hello from C.M4"
-           printfn "hello from C.M4"
-           printfn "hello from C.M4"
-           printfn "hello from C.M4"
-           printfn "hello from C.M4"
-           printfn "hello from C.M4"
-           1+2
-    f()
-    List.map f [();();()]
-    f2()
-    List.map f2 [();();()]
-    f2()
-    List.map f3 [();();()]
-    f3()
-    List.map f4 [();();()]
-    f4()
-    List.map f5 [();();()]
-    f5()
-    List.map C.M [();();()]
-    C.M()
-    let c = C(3)
-    c.M2()
-    List.map c.M2 [();();()]
-    c.M3()
-    List.map c.M3 [();();()]
-    c.M4() () 
-    List.map (c.M4 ()) [();();()]
-    
-//---------------------------------------------------------------------
-// Finish up
-
-
-
-
-module SingleArgumentFunctions =
-    type C() = 
-        let f0 () = 1
-        let f1 (x:int) = x
-        let f2 (x:int) = f1 x + f0()
-        let rec f3 (x:int) = 2
-        let f4 (x:int) = f3 x + f0()
-        let v = f4 5
-        let f5 (x:int) = f4 v + 6
-        let rec f6 (x:int) = if x = 0 then 6 else f6 (x-1)
-        let v2 = f6 5
-        let v3 = List.map f0 [(); ()]
-        let v4 = List.map f1 [1;2]
-        let v5 = List.map f3 [1;2]
-        member x.Result =     
-            List.sum v3 + List.sum v4 + List.sum v5  + v2 + v
-
-    let c = C()
-    printfn "c.Result = %d" c.Result
-    test "vrewiorvw09j" (c.Result = 18)
-
-module MultiArgumentFunctions =
-    type C() = 
-        let f1 (x1:int) x2 = x1 + x2
-        let v5 = f1 2 3
-        member x.Result =     
-            f1 3 4 + v5
-
-    let c = C()
-    printfn "c.Result = %d" c.Result
-    test "vrewiorvw09h" (c.Result = 12)
-
-
-
-module TupledMultiArgumentFunctions =
-    type C() = 
-        let f1 (x1:int,x2:int) (x3:int,x4:int) = x1 + x2 + x3 + x4
-        let v5 = f1 (2,3) (4,5)
-        member x.Result =     
-            f1 (6,7) (8,9) + v5
-
-    let c = C()
-    printfn "c.Result = %d" c.Result
-    test "vrewiorvw09g" (c.Result = 44)
-
-module FunctionInGenericClass =
-    type C<'a>() = 
-        let f1 (x1:int) = x1 + 3
-        let v5 = f1 3
-        member x.Result =     
-            f1 6  + v5
-
-    let c = C<int>()
-    printfn "c.Result = %d" c.Result
-    test "vrewiorvw09f" (c.Result = 15)
-
-module GenericFunctions =
-    type C() = 
-        let f1 x1 = x1
-        let f2 (x : 'a) : 'a when 'a :> System.IComparable = x
-        let v5 = f1 3
-        let v6 = f1 "hello"
-        let v7 = f2 1
-        let v8 = f2 "hello"
-        member x.Result =     
-            f1 6  + v5 + v6.Length
-
-    let c = C()
-    printfn "c.Result = %d" c.Result
-    test "vrewiorvw09d" (c.Result = 14)
-
-module GenericFunctionInGenericClass =
-    type C<'a>() = 
-        let f1 x1 = x1 
-        let rec f2 n x1 = if n = 0 then x1  else f2 (n-1) x1
-        let rec f3 n (x1:int) = if n = 0 then x1  else f2 (n-1) x1
-        let v5 = f1 3 + sizeof<'a>
-        let v6 = f1 "hello"
-        let v7 = f2 8 3 + sizeof<'a>
-        let v8 = f2 10 "hello"
-        let v9 = f3 8 3 + sizeof<'a>
-        member x.Result =     
-            f1 6  + v5 + v6.Length + v7 + v8.Length + f2 8 6 + f3 8 6
-        member x.Functions =     
-            (f1 : int -> int), (f1 : string -> string),
-            (f2 : int -> int -> int), (f2 : int -> string -> string),
-            // Non generic function in generic class used as a first class value
-            (f3 : int -> int -> int)
-
-    let c = C<int>()
-    printfn "c.Result = %d" c.Result
-    let c2 = C<System.DateTime>()
-    printfn "c2.Result = %d" c2.Result
-    test "vrewiorvw09s" (c.Result = 42)
-    test "vrewiorvw09a" (c2.Result = 50)
-
-module TailCallLoop =
-    type C<'a>() = 
-        let rec f x = if x = 0 then 1 else f (x  - 1)
-        let v5 = f 10000000
-        member x.Result =     
-            f 10000000 + v5
-
-    let c = C<int>()
-    printfn "c.Result = %d" c.Result
-    let c2 = C<System.DateTime>()
-    printfn "c2.Result = %d" c2.Result
-    test "vrewiorvw09o" (c.Result = 2)
-    test "vrewiorvw09i" (c2.Result = 2)
-
-module FunctionsAsLambdas =
-    type C() = 
-        let f0 = fun () -> 1
-        let f1 = fun (x:int) -> x
-        let f2 = fun (x:int) -> f1 x + f0()
-        let rec f3 = fun (x:int) -> 2
-        let f4 = fun (x:int) -> f3 x + f0()
-        let v = f4 5
-        let f5 = fun (x:int) -> f4 v + 6
-        let rec f6 = fun (x:int) -> if x = 0 then 6 else f6 (x-1)
-        let v2 = f6 5
-        let v3 = List.map f0 [(); ()]
-        let v4 = List.map f1 [1;2]
-        let v5 = List.map f3 [1;2]
-        let f6 = fun (x1:int) x2 -> x1 + x2
-        let v6 = f6 2 3
-        let f7 = fun (x1:int,x2:int) (x3:int,x4:int) -> x1 + x2 + x3 + x4
-        let v7 = f7 (2,3) (4,5)
-        let f8 = fun (x1:int,x2:int) () -> x1 + x2 
-        let v8 = f8 (2,3) ()
-        let f9 = fun () -> fun (x1:int,x2:int) -> x1 + x2 
-        let v9 = f9 () (2,3) 
-        let f10 = fun  x1 -> x1
-        let v10a = f10 3
-        let v10b = f10 "hello"
-        member x.Result =     
-            List.sum v3 + List.sum v4 + List.sum v5 + v2 + v + v6 + v7 + v8 + v9 + v10a + v10b.Length
-
-    let c = C()
-    printfn "c.Result = %d" c.Result
-    test "vrewiorvw09u" (c.Result = 55)
-
-
-
-module Pathological1 =
-    type C<'a>() = 
-        let mutable f1  = fun x1 -> x1 
-        let v5 = f1 3 + sizeof<'a>
-        member x.Result =     
-            f1 6  + v5 
-
-    let c = C<int>()
-    printfn "c.Result = %d" c.Result
-    let c2 = C<System.DateTime>()
-    printfn "c2.Result = %d" c2.Result
-    test "vrewiorvw09y" (c.Result = 13)
-    test "vrewiorvw09t" (c2.Result = 17)
-    
-
-
-module StaticSingleArgumentFunctions =
-    type C() = 
-        static let f0 () = 1
-        static let f1 (x:int) = x
-        static let f2 (x:int) = f1 x + f0()
-        static let rec f3 (x:int) = 2
-        static let f4 (x:int) = f3 x + f0()
-        static let v = f4 5
-        static let f5 (x:int) = f4 v + 6
-        static let rec f6 (x:int) = if x = 0 then 6 else f6 (x-1)
-        static let v2 = f6 5
-        static let v3 = List.map f0 [(); ()]
-        static let v4 = List.map f1 [1;2]
-        static let v5 = List.map f3 [1;2]
-        static member Result =     
-            List.sum v3 + List.sum v4 + List.sum v5  + v2 + v
-
-    printfn "c.Result = %d" C.Result
-    test "vrewiorvw09r" (C.Result = 18)
-
-module StaticMultiArgumentFunctions =
-    type C() = 
-        static let f1 (x1:int) x2 = x1 + x2
-        static let v5 = f1 2 3
-        static member Result =     
-            f1 3 4 + v5
-
-    printfn "c.Result = %d" C.Result
-    test "vrewiorvw09e" (C.Result = 12)
-
-module StaticTupledMultiArgumentFunctions =
-    type C() = 
-        static let f1 (x1:int,x2:int) (x3:int,x4:int) = x1 + x2 + x3 + x4
-        static let v5 = f1 (2,3) (4,5)
-        static member Result =     
-            f1 (6,7) (8,9) + v5
-
-    printfn "c.Result = %d" C.Result
-    test "vrewiorvw09w" (C.Result = 44)
-
-module StaticFunctionInGenericClass =
-    type C<'a>() = 
-        static let f1 (x1:int) = x1 + 3 + sizeof<'a>
-        static let v5 = f1 3
-        static member Result =     
-            f1 6  + v5
-
-    printfn "C<int>.Result = %d" (C<int>.Result)
-    printfn "C<System.DateTime>.Result = %d" (C<System.DateTime>.Result)
-    test "vrewiorvw09q" (C<int>.Result = 23)
-    test "vrewiorvw099" (C<System.DateTime>.Result = 31)
-
-module StaticGenericFunctions =
-    type C() = 
-        static let f1 x1 = x1
-        static let f2 (x : 'a) : 'a when 'a :> System.IComparable = x
-        static let v5 = f1 3
-        static let v6 = f1 "hello"
-        static let v7 = f2 1
-        static let v8 = f2 "hello"
-        static member Result =     
-            f1 6  + v5 + v6.Length
-
-    printfn "c.Result = %d" C.Result
-    test "vrewiorvw098" (C.Result = 14)
-
-module StaticGenericFunctionInGenericClass =
-    type C<'a>() = 
-        static let f1 x1 = x1 
-        static let rec f2 n x1 = if n = 0 then x1  else f2 (n-1) x1
-        static let rec f3 n (x1:int) = if n = 0 then x1  else f2 (n-1) x1
-        static let v5 = f1 3 + sizeof<'a>
-        static let v6 = f1 "hello"
-        static let v7 = f2 8 3 + sizeof<'a>
-        static let v8 = f2 10 "hello"
-        static let v9 = f3 8 3 + sizeof<'a>
-        static member Result =     
-            f1 6  + v5 + v6.Length + v7 + v8.Length + f2 8 6 + f3 8 6
-        static member Functions =     
-            (f1 : int -> int), (f1 : string -> string),
-            (f2 : int -> int -> int), (f2 : int -> string -> string),
-            // Non generic function in generic class used as a first class value
-            (f3 : int -> int -> int)
-
-    printfn "C<int>.Result = %d" (C<int>.Result)
-    printfn "C<System.DateTime>.Result = %d" (C<System.DateTime>.Result)
-    test "vrewiorvw097" (C<int>.Result = 42)
-    test "vrewiorvw096" (C<System.DateTime>.Result = 50)
-
-module StaticTailCallLoop =
-    type C<'a>() = 
-        static let rec f x = if x = 0 then sizeof<'a> else f (x  - 1)
-        static let v5 = f 10000000
-        static member Result =     
-            f 10000000 + v5
-
-    printfn "C<int>.Result = %d" (C<int>.Result)
-    printfn "C<System.DateTime>.Result = %d" (C<System.DateTime>.Result)
-    test "vrewiorvw095" (C<int>.Result = 8)
-    test "vrewiorvw094" (C<System.DateTime>.Result = 16)
-
-module StaticFunctionsAsLambdas =
-    type C() = 
-        static let f0 = fun () -> 1
-        static let f1 = fun (x:int) -> x
-        static let f2 = fun (x:int) -> f1 x + f0()
-        static let rec f3 = fun (x:int) -> 2
-        static let f4 = fun (x:int) -> f3 x + f0()
-        static let v = f4 5
-        static let f5 = fun (x:int) -> f4 v + 6
-        static let rec f6 = fun (x:int) -> if x = 0 then 6 else f6 (x-1)
-        static let v2 = f6 5
-        static let v3 = List.map f0 [(); ()]
-        static let v4 = List.map f1 [1;2]
-        static let v5 = List.map f3 [1;2]
-        static let f6 = fun (x1:int) x2 -> x1 + x2
-        static let v6 = f6 2 3
-        static let f7 = fun (x1:int,x2:int) (x3:int,x4:int) -> x1 + x2 + x3 + x4
-        static let v7 = f7 (2,3) (4,5)
-        static let f8 = fun (x1:int,x2:int) () -> x1 + x2 
-        static let v8 = f8 (2,3) ()
-        static let f9 = fun () -> fun (x1:int,x2:int) -> x1 + x2 
-        static let v9 = f9 () (2,3) 
-        static let f10 = fun  x1 -> x1
-        static let v10a = f10 3
-        static let v10b = f10 "hello"
-        static member Result =     
-            List.sum v3 + List.sum v4 + List.sum v5 + v2 + v + v6 + v7 + v8 + v9 + v10a + v10b.Length
-
-    printfn "c.Result = %d" C.Result
-    test "vrewiorvw093" (C.Result = 55)
-
-
-
-module StaticPathological1 =
-    type C<'a>() = 
-        static let mutable f1  = fun x1 -> x1 
-        static let v5 = f1 3 + sizeof<'a>
-        static member Result =     
-            f1 6  + v5 
-
-    printfn "C<int>.Result = %d" (C<int>.Result)
-    printfn "C<System.DateTime>.Result = %d" (C<System.DateTime>.Result)
-    test "vrewiorvw092" (C<int>.Result = 13)
-    test "vrewiorvw091" (C<System.DateTime>.Result = 17)
-
-module ImplicitOperatorTests =
-    type Foo(x : int) = 
-        member this.Val = x
-        
-        static member (-->) ((src : Foo), (target : Foo)) = new Foo(src.Val + target.Val)
-        static member (-->) ((src : Foo), (target : int)) = new Foo(src.Val + target)
-
-        static member (!!) (src : Foo) = new Foo(-src.Val)
-            
-        static member (+) ((src : Foo), (target : Foo)) = new Foo(src.Val + target.Val)
-        static member (+) ((src : Foo), (target : int)) = new Foo(src.Val + target)
-        
-    let x = Foo(3) --> 4  
-    let y = Foo(3) --> Foo(5)  
-    let z = (-->) (Foo(3)) (Foo(5))
-    let f1 : Foo -> Foo = (-->) (Foo(3)) 
-    let _  = f1  (Foo(5)) 
-    let f2 : int -> Foo = (-->) (Foo(3)) 
-    let _  = f2  3
-    let x2 = Foo(3) + 4  
-    let y2 = Foo(3) + Foo(4)  
-    let z2 = !!Foo(3) 
-
-module SlicingTests =
-    let s1 = "abcdef"
-
-    check "ce0cew9j1" s1.[2..] "cdef"
-    check "ce0cew9j2" s1.[2..2] "c"
-    check "ce0cew9j3" s1.[5..5] "f"
-    check "ce0cew9j4" s1.[0..0] "a"
-    check "ce0cew9j5" s1.[2..1] ""
-    check "ce0cew9j6" s1.[0.. -1] ""
-    check "ce0cew9j7" s1.[2..3] "cd"
-    check "ce0cew9j8" s1.[2..4] "cde"
-    check "ce0cew9j9" s1.[2..5] "cdef"
-
-
-    let a1 = [| for c in "abcdef" -> c |]
-
-    check "ce0cew9jq" a1.[2..] [| for c in "cdef" -> c |]
-
-    a1.[3..] <- [| for c in "DEF" -> c |]
-
-    check "ce0cew9jw" a1.[2..] [| for c in "cDEF" -> c |]
-
-    let m1 = Array2D.init 6 7 (fun i j -> i + 2*j)
-
-    check "ce0cew9je" m1 (Array2D.init 6 7 (fun i j -> i + 2*j))
-    for i = 1 to 5 do 
-        for j = 1 to 6 do 
-            check "ce0cew9jr" m1.[1..i,1..j] (Array2D.init i j (fun i j -> (i+1) + 2*(j+1)))
-
-
-    m1.[1..3,1..4] <- Array2D.zeroCreate 3 4
-
-    for i = 1 to 5 do 
-        for j = 1 to 6 do 
-            check "ce0cew9js" m1.[1..i,1..j] (Array2D.init i j (fun i j -> if (i+1) >= 1 && (i+1) <= 3 && (j+1) >= 1 && (j+1) <= 4 then 0 else (i+1) + 2*(j+1)))
-
-
-
-    type System.Int32 with 
-        member x.GetSlice(idx1,idx2) = 
-            let idx1 = defaultArg idx1 0
-            let idx2 = defaultArg idx2 17
-            x % (17 * idx1 + idx2)
-        member x.GetSlice(idx1,idx2,idx3,idx4) = 
-            let idx1 = defaultArg idx1 0
-            let idx2 = defaultArg idx2 17
-            let idx3 = defaultArg idx3 17
-            let idx4 = defaultArg idx4 17
-            x % (17 * idx1 + idx2 + idx3 + idx4)
-
-    (3).[3..4]
-    (3).[3..]
-    (3).[..4]
-
-    (3).[3..4,4..5]
-    (3).[3..,6..7]
-    (3).[..4,8..9]
-    (3).[..4,*]
-    (3).[*,*]
-
-    type Foo() =
-        member this.GetSlice(lb1:int option, ub1:int option) = [1]
-        member this.SetSlice(lb1:int option, ub1:int option, v2D: int list) = ()
-
-    let f = new Foo()
-
-    let vs = f.[1 .. 3]
-    f.[1..3] <- [3]
-    f.[..3] <- [3]
-    f.[1..] <- [3]
-    f.[*] <- [3]
-
-module Bug_FSharp_1_0_3246 =
-    type R1 =  
-        { x : int }
-        static member Empty = { x = 3 } 
-       
-    and R2 = 
-        { x : int }
-        static member Empty = { x = 3 }
-
-    let r1 : R1 = R1.Empty
-    let r2 : R2 = R2.Empty
-
-module First_class_use_of_non_overloaded_method_should_detuple_1 =
-
-    let count = ref 0
-    type A() = 
-        let f (x,y) = incr count; printfn "hello"; incr count
-        member this.M0 () = f (1,2)
-        member this.M1 (x:int) = f (x,x)
-        member this.M2 (x:int,y:float) = f (x,y)
-
-        static member SM0 () = incr count; printfn "hello"; incr count
-        static member SM1 (x:int) = incr count; printfn "hello"; incr count
-        static member SM2 (x:int,y:float) = incr count; printfn "hello"; incr count
-
-
-    [| (1,3.0) |] |> Array.iter (fun (x,y) -> A.SM2 (x,y))
-    [| (1,3.0) |] |> Array.iter (fun d -> A.SM2 d)
-    [| (1,3.0) |] |> Array.iter A.SM2 
-
-    [| 1;2;3 |] |> Array.iter (fun d -> A.SM1 d)
-    [| 1;2;3 |] |> Array.iter A.SM1 
-
-    [| ();();() |] |> Array.iter (fun d -> A.SM0())
-    [| ();();() |] |> Array.iter A.SM0 
-
-    let a = A()
-    [| (1,3.0) |] |> Array.iter (fun (x,y) -> a.M2 (x,y))
-    [| (1,3.0) |] |> Array.iter (fun d -> a.M2 d)
-    [| (1,3.0) |] |> Array.iter a.M2 
-
-    [| 1;2;3 |] |> Array.iter (fun d -> a.M1 d)
-    [| 1;2;3 |] |> Array.iter a.M1 
-
-    [| ();();() |] |> Array.iter (fun d -> a.M0())
-    [| ();();() |] |> Array.iter a.M0 
-
-module First_class_use_of_non_overloaded_method_should_detuple_2 =
-
-    let count = ref 0
-    type A<'a>() = 
-        let f (x,y) = incr count; printfn "hello"; incr count
-        member this.M0 () = f (1,2)
-        member this.M1 (x:'a) = f (x,x)
-        member this.M2 (x:'a,y:'a) = f (x,y)
-
-        static member SM0 () = incr count; printfn "hello"; incr count
-        static member SM1 (x:'a) = incr count; printfn "hello"; incr count
-        static member SM2 (x:'a,y:'a) = incr count; printfn "hello"; incr count
-
-
-    [| (1,3) |] |> Array.iter (fun (x,y) -> A.SM2 (x,y))
-    [| (1,3) |] |> Array.iter (fun d -> A.SM2 d)
-    [| (1,3) |] |> Array.iter A.SM2 
-
-    [| 1;2;3 |] |> Array.iter (fun d -> A.SM1 d)
-    [| 1;2;3 |] |> Array.iter A.SM1 
-
-    [| ();();() |] |> Array.iter (fun d -> A.SM1 d)
-    [| ();();() |] |> Array.iter A.SM1 
-
-    [| ();();() |] |> Array.iter (fun d -> A<int>.SM0())
-    [| ();();() |] |> Array.iter A<int>.SM0 
-
-    let a = A<int>()
-    [| (1,3) |] |> Array.iter (fun (x,y) -> a.M2 (x,y))
-    [| (1,3) |] |> Array.iter (fun d -> a.M2 d)
-    [| (1,3) |] |> Array.iter a.M2 
-
-    let au = A<unit>()
-    [| ();();() |] |> Array.iter (fun d -> au.M1 d)
-    [| ();();() |] |> Array.iter au.M1 
-
-    [| 1;2;3 |] |> Array.iter (fun d -> a.M1 d)
-    [| 1;2;3 |] |> Array.iter a.M1 
-
-    [| ();();() |] |> Array.iter (fun d -> a.M0())
-    [| ();();() |] |> Array.iter a.M0 
-
-
-module First_class_use_of_non_overloaded_method_should_detuple_3 =
-
-    let count = ref 0
-    type A() = 
-        let f (x,y) = ()
-        member this.M0 () = f (1,2)
-        member this.M1 (x:'a) = f (x,x)
-        member this.M2 (x:'a,y:'a) = f (x,y)
-
-        static member SM0 () = ()
-        static member SM1 (x:'a) = ()
-        static member SM2 (x:'a,y:'a) = ()
-
-
-    [| (1,3) |] |> Array.iter (fun (x,y) -> A.SM2 (x,y))
-    [| (1,3) |] |> Array.iter (fun d -> A.SM2 d)
-    [| (1,3) |] |> Array.iter A.SM2 
-
-    [| 1;2;3 |] |> Array.iter (fun d -> A.SM1 d)
-    [| 1;2;3 |] |> Array.iter A.SM1 
-
-    [| ();();() |] |> Array.iter (fun d -> A.SM1 d)
-    [| ();();() |] |> Array.iter A.SM1 
-
-    [| ();();() |] |> Array.iter (fun d -> A.SM0())
-    [| ();();() |] |> Array.iter A.SM0 
-
-    let a = A()
-    [| (1,3) |] |> Array.iter (fun (x,y) -> a.M2 (x,y))
-    [| (1,3) |] |> Array.iter (fun d -> a.M2 d)
-    [| (1,3) |] |> Array.iter a.M2 
-
-    [| ();();() |] |> Array.iter (fun d -> a.M1 d)
-    [| ();();() |] |> Array.iter a.M1 
-
-    [| 1;2;3 |] |> Array.iter (fun d -> a.M1 d)
-    [| 1;2;3 |] |> Array.iter a.M1 
-
-    [| ();();() |] |> Array.iter (fun d -> a.M0())
-    [| ();();() |] |> Array.iter a.M0 
-
-module Bug_1438 = 
-
-    type Tuples =
-        static member Sel1 t = match t with | (a,_) -> a
-
-        static member Sel2 t = match t with | (_,b) -> b
-
-    let unzip (xs : seq<'a * 'b>) : seq<'a> * seq<'b> =
-        ( xs |> Seq.map (fun x -> Tuples.Sel1 x),
-          xs |> Seq.map (fun x -> Tuples.Sel2 x) )
-
-    let unzip2 (xs : seq<'a * 'b>) : seq<'a> * seq<'b> =
-        ( xs |> Seq.map Tuples.Sel1,
-          xs |> Seq.map Tuples.Sel2 )
-
-module InheritingFromPartiallyImplementedTypes = 
-    module PositiveTests = 
-
-
-
-        module Test2 = 
-            type ITest =
-                abstract member Meth1: string -> string
-
-            type ITestSub =
-                inherit ITest
-                abstract member Meth2: int -> int
-
-            type OkComplete () =
-                interface ITest with
-                    override this.Meth1 x = x + "1"
-                interface ITestSub with
-                    override this.Meth2 x = x + 1
-
-            module Throwaway =
-                let foo = OkComplete()
-
-
-        module Test4 = 
-            [<AbstractClass>]
-            type wire<'a>() =
-                abstract Send   : 'a -> unit
-
-            let createWire() =
-              {new wire<'a>() with 
-                  member obj.Send(x:'a)   = ()
-              }
-
-            type CreateWire<'a>() =
-              inherit wire<'a>() 
-              override obj.Send(x)   = ()
-
-
-        module Test5 = 
-            type ITest =
-                abstract member Meth1: int -> int
-
-            type ITestSub =
-                inherit ITest
-                abstract member Meth1: int -> int
-
-            [<AbstractClass>]
-            type Partial() =
-                abstract Meth1 : int -> int
-                interface ITest with
-                    override this.Meth1 x = this.Meth1 x
-                interface ITestSub with
-                    override this.Meth1 x = this.Meth1 x
-
-            type OkComplete () =
-                inherit Partial()
-                override this.Meth1 x = x
-
-            module Throwaway =
-                let foo = OkComplete()
-
-    module MorePositiveTests =
-
-
-          type IEnumerator<'T> = 
-              abstract Current : 'T
-          
-          [<AbstractClass>]
-          type MapEnumerator<'T> (x:'T) =
-              interface IEnumerator<'T> with
-                  member this.Current = x
-              
-          type MapE<'U>() =
-              inherit MapEnumerator<'U>(failwith "")
-
-
-    module MorePositiveTEsts2 = 
-        open System.Reflection
-
-        type IDelegateEvent<'del when 'del :> System.Delegate > =
-            abstract AddHandler: handler:'del -> unit
-
-        type IEvent<'del,'args when 'del :> System.Delegate > =
-            inherit IDelegateEvent<'del>
-
-        let f<'Delegate,'Args when 'Delegate :> System.Delegate >() = 
-                { new IEvent<'Delegate,'Args> with 
-                    member x.AddHandler(d) = () }
-
-
-    module MorePositiveTEsts3 = 
-
-        type IEvent<'del,'a> = 
-            abstract Add : ('a -> unit) -> unit
-            
-        [<AbstractClass>]
-        type wire<'a>() =
-            abstract Send   : 'a -> unit
-            abstract Listen : ('a -> unit) -> unit
-            interface IEvent<Handler<'a>,'a> with
-                member x.Add(handler) = x.Listen(handler)
-
-        let createWire() =
-            let listeners = ref [] in
-            {new wire<'a>() with   // Expect an error here - Add2 no implemented
-              member obj.Send(x)   = List.iter (fun f -> f x) !listeners   
-              member obj.Listen(f) = listeners := f :: !listeners
-            }
-
-module MoreConstraintTEsts = 
-    type C1<'T when 'T :> System.Array>() =
-        member x.P = 1
-
-    type C2<'T when 'T :> System.Delegate>() =
-        member x.P = 1
-
-    type C3<'T when 'T :> System.Enum>() =
-        member x.P = 1
-
-
-    type C4<'T when 'T :> System.ValueType>() =
-        member x.P = 1
-
-    type C5<'T when 'T :> System.IComparable and 'T :> System.IComparable>() =
-        member x.P = 1
-
-
-    type C6<'T when 'T :> System.Array and 'T :> System.Array>() =
-        member x.P = 1
-
-    type C7<'T when 'T :> System.Array and 'T :> System.IComparable>() =
-        member x.P = 1
-// Can't constraint to multiple class types anymore
-// It is ok to constrain to multiple interfaces though.
-    type C8<'T when 'T :> System.Array and 'T :> System.IComparable and 'T :> System.ICloneable>() =
-        member x.P = 1
-
-    let f x = new C8<_>()
-
-module FinalizerTEst = 
-    type S<'a>(x:'a) =   class [<DefaultValue(false)>] val mutable x : 'a override x.Finalize() = printfn "hello" end
-
-    let x = S(3) |> box
-
-module CheckBoxingSemantics = 
-    module StructTest1 = 
-
-        type IX = abstract ToStringMember : unit -> string
-
-
-        [<Struct>]
-        type Counter = 
-          interface IX with 
-            member x.ToStringMember() = x.value <- x.value + 1; x.value.ToString()
-           
-          [<DefaultValue>]
-          val mutable value : int 
-
-        let x = ref (new Counter())
-
-        let f (x:'a when 'a :> IX) = 
-            [ x.ToStringMember(); x.ToStringMember(); x.ToStringMember() ]
-
-        check "vklnvwer0" (f x.Value) ["1"; "1"; "1"]
-
-    module StructTest2 = 
-
-
-        [<Struct>]
-        type Counter = 
-          [<DefaultValue>]
-          val mutable value : int 
-          member x.ToStringMember() = x.value <- x.value + 1; x.value.ToString()
-
-        let x = ref (new Counter());
-
-        check "vklnvwer0" [ x.contents.ToStringMember(); x.contents.ToStringMember(); x.contents.ToStringMember() ] ["1"; "2"; "3"]
-
-    module StructTest3 = 
-
-        [<Struct>]
-        type Counter = 
-          [<DefaultValue>]
-          val mutable value : int 
-          member x.ToStringMember() = x.value <- x.value + 1; x.value.ToString()
-
-        let x = Array.init 3 (fun i -> new Counter());
-        check "vklnvwer0" [ x.[0].ToStringMember(); x.[0].ToStringMember(); x.[0].ToStringMember() ] ["1"; "2"; "3"]
-
-    module StructTest4 = 
-
-        [<Struct>]
-        type Counter = 
-          [<DefaultValue>]
-          static val mutable private value : int 
-          member x.ToStringMember() = Counter.value <- Counter.value + 1; Counter.value.ToString()
-
-        let x = Array.init 3 (fun i -> new Counter());
-        check "vklnvwer0" [ x.[0].ToStringMember(); x.[0].ToStringMember(); x.[0].ToStringMember() ] ["1"; "2"; "3"]
-
-
-
-
-module InterfaceExtendsSystemIComparable_Bug4919 = 
-      open System.Collections
-      open System.Collections.Generic
-
-      exception EmptyQueue
-
-      type Queue<'a> =
-        inherit IEnumerable<'a>
-        inherit IEnumerable
-        inherit System.IEquatable<Queue<'a>>
-        inherit System.IComparable
-        abstract IsEmpty : bool
-        abstract PushBack : 'a -> Queue<'a>
-        abstract PopFront : unit -> 'a * Queue<'a>
-
-      let private queueEnumerator (q: Queue<_>) =
-        let decap (q: Queue<_>) = if q.IsEmpty then None else Some(q.PopFront())
-        (Seq.unfold decap q).GetEnumerator()
-
-      module BatchedQueue =
-        let rec private mk(f, r) =
-          let mk = function
-            | [], r -> mk(List.rev r, [])
-            | q -> mk q
-          { new Queue<'a> with
-              override q.IsEmpty =
-                match f with
-                | [] -> true
-                | _ -> false
-
-              override q.PushBack x =
-                mk(f, x::r)
-
-              override q.PopFront() =
-                match f with
-                | x::f -> x, mk(f, r)
-                | [] -> raise EmptyQueue
-
-              override q.GetEnumerator() =
-                ((q: Queue<'a>).GetEnumerator() :> IEnumerator)
-
-              override q.GetEnumerator() : IEnumerator<'a> =
-                queueEnumerator q
-
-              override q1.Equals(q2: Queue<'a>) =
-                List.ofSeq q1 = List.ofSeq q2
-
-              override q1.CompareTo(q2: obj) =
-                let q2 = unbox<Queue<'a>> q2
-                Seq.compareWith compare q1 q2
-         }
-
-        let empty<'a when 'a : equality and 'a : comparison> = mk<'a>([], [])
-
-        let add (q: Queue<_>) x = q.PushBack x
-
-        let take (q: Queue<_>) = q.PopFront()
-
-      let time f x =
-        let t = System.Diagnostics.Stopwatch.StartNew()
-        try f x finally
-        printf "Took %dms\n" t.ElapsedMilliseconds
-
-      let _ =
-        time (Seq.length << Seq.fold BatchedQueue.add BatchedQueue.empty) (seq {1 .. 100})
-        |> printf "Queue length %d\n"
-
-module AllowExtensionsWithinARecursiveGroup = begin
-    type System.Object with 
-       member x.Name = "a"
-
-    and System.String with 
-       member x.Freddy = "b"
-
-    and C with  
-       member x.FreddyAndName = let a,b = x.NameAndFreddy in b,a
-       
-    and C(s:string) = 
-       member x.NameAndFreddy = s.Name, s.Freddy
-
-end
-
-
-
-module PreferOverloadsUsingSystemFunc = begin
-
-    type Foo() = 
-        static member Method(x:System.Action) = 1
-        static member Method(x:System.Func<'T>) = 2
-
-    Foo.Method(fun _ -> ()) // expect return result 2
-end
-
-
-module AllowNullLiteralTest = begin
-
-    [<AllowNullLiteral>]
-    type I = 
-        interface
-          abstract P : int
-        end
-
-    let i = (null : I)
-
-    let i2 = ((box null) :?>  I)
-
-
-    [<AllowNullLiteral>]
-    type C() = 
-        member x.P = 1
-
-    let c = (null : C)
-
-    let c2 = ((box null) :?>  C)
-
-
-    [<AllowNullLiteral>]
-    type D() = 
-        inherit C()
-        interface I with 
-            member x.P = 2
-        member x.P = 1
-
-    let d = (null : D)
-
-    let d2 = ((box null) :?>  D)
-
-end
-
-module UnionConstructorsAsFirstClassValues = begin
-    type A =
-        | A of int * int
-        
-    let x = (1, 1)
-    let y = (A) x // OK
-    let z = A x // expect this to be ok
-end
-
-
-module ExtensionMemberTests = 
-    module Set1 = 
-        type System.DateTime with 
-           static member Prop1 = (1,1)
-
-        type System.DateTime with 
-           static member Meth1(s:string) = (1,2)
-
-        type System.DateTime with 
-           static member Meth2(s:string) = (1,2)
-
-        type System.DateTime with 
-           member x.InstanceProp1 = (1,1)
-
-        type System.DateTime with 
-           member x.InstanceMeth1(s:string) = (1,2)
-
-        type System.DateTime with 
-           member x.InstanceMeth2(s:string) = (1,2)
-
-
-    module Set2 = 
-        type System.DateTime with 
-           static member Prop1 = (2,2)
-
-        type System.DateTime with 
-           static member Meth1(s:string) = (2,1)
-
-        type System.DateTime with 
-           static member Meth2(s:obj) = (2,1)
-
-        type System.DateTime with 
-           member x.InstanceProp1 = (2,2)
-
-        type System.DateTime with 
-           member x.InstanceMeth1(s:string) = (2,1)
-
-        type System.DateTime with 
-           member x.InstanceMeth2(s:obj) = (2,1)
-    
-    // overloaded indexed extension properties
-    module Set3A =
-        type A() = 
-            member m.Item with get(a: string) = "Item(string)"
-            member m.Item with set(a: string) (value:string) = failwith "Setting Item(string) string"
-            member m.Item with set(a: bool) (value:string) = failwith "Setting Item(bool) string"
-                
-            member m.Prop with get(a: string, b:string) = "Prop(string, string)"
-            member m.Prop with set(a: string, b: string) (value:string) = failwith "Setting Prop(string, string) string"
-            member m.Prop with set(a: string, b: bool) (value:string) = failwith "Setting Prop(string, bool) string"
-            
-            member m.Plain with get() = "Intrinsic plain"
-            member m.Plain with set(a:string) = failwith "Setting intrinsic plain"
-            
-            member m.NonIndexed with get() = "Intrinsic nonindexed"
-            
-            member m.Indexed with get(a: string) = "Intrinsic indexed"
-
-
-    module Set3B =
-        type Set3A.A with
-            member m.Item with get(a: bool) = "Item(bool)"
-            member m.Item with set(a: bool) (value: bool) = failwith "Setting Item(bool) bool"
-            member m.Item with set(a: string) (value: bool) = failwith "Setting Item(string) bool"
-                
-            member m.Prop with get(a: string, b:bool) = "Prop(string, bool)"
-            member m.Prop with set(a: string, b:bool) (value: bool) = failwith "Setting Prop(string, bool) bool"
-            member m.Prop with set(a: string, b:string) (value: bool) = failwith "Setting Prop(string, string) bool"
-            
-            member m.Plain with get() = "Extension plain"
-            member m.Plain with set(a:string) = failwith "Setting extension plain"
-            
-            member m.NonIndexed with get(a: bool) = "Extension nonindexed"
-            
-            member m.Indexed with get() = "Extension indexed"
-            
-            member m.ExtensionOnly with get(a: bool) = "ExtensionOnly(bool)"
-            
-        type System.Net.WebHeaderCollection with
-            member m.Item with get(a : bool) = "ExtensionGet"
-
-    module Tests1 = 
-        open Set1
-        open Set2
-        check "fewnr-0vrwep0" System.DateTime.Prop1 (2,2)
-        check "fewnr-0vrwep1" (System.DateTime.Meth1("a")) (2,1)
-        check "fewnr-0vrwep2" (System.DateTime.Meth2("a")) (1,2) // Set1 always preferred due to more precise type
-
-        check "fewnr-0vrwep0" System.DateTime.Now.InstanceProp1 (2,2)
-        check "fewnr-0vrwep1" (System.DateTime.Now.InstanceMeth1("a")) (2,1)
-        check "fewnr-0vrwep2" (System.DateTime.Now.InstanceMeth2("a")) (1,2) // Set1 always preferred due to more precise type
-
-    module Tests2 = 
-        open Set2
-        open Set1
-        check "fewnr-0vrwep3" System.DateTime.Now.InstanceProp1 (1,1)
-        check "fewnr-0vrwep4" (System.DateTime.Now.InstanceMeth1("a")) (1,2)
-        check "fewnr-0vrwep5" (System.DateTime.Now.InstanceMeth2("a")) (1,2) // Set1 always preferred due to more precise type
-
-    module Tests3 = 
-        open Set3A
-        open Set3B
-        
-        let checkSet testName (f : unit -> unit) expected =
-            let result = 
-                let mutable res = ""
-                try f() with | e -> res <- e.Message
-                res
-                
-            check testName result expected
-        
-        let foo = A()
-        
-        // getters
-        check "ExtensionProps 0" (foo.[""]) "Item(string)"
-        check "ExtensionProps 1" (foo.[true]) "Item(bool)"
-
-        check "ExtensionProps 2" (foo.Prop("", "")) "Prop(string, string)"
-        check "ExtensionProps 3" (foo.Prop("", true)) "Prop(string, bool)"
-        
-        // in case of exact duplicate, per spec intrinsic should be preferred
-        check "ExtensionProps 4" (foo.Plain) "Intrinsic plain"
-        
-        check "ExtensionProps 5" (foo.NonIndexed) "Intrinsic nonindexed"
-        // not expected to work:  check "ExtensionProps 6" (foo.NonIndexed(true)) "Extension nonindexed"
-        
-        check "ExtensionProps 7" (foo.Indexed("")) "Intrinsic indexed"
-        // not expected to work:  check "ExtensionProps 8" (foo.Indexed) "Extension indexed"
-        
-        check "ExtensionProps 9" (System.Net.WebHeaderCollection().[true]) "ExtensionGet"
-        
-        // setters
-        checkSet "ExtensionProps 10" (fun () -> foo.[""] <- "") "Setting Item(string) string"
-        checkSet "ExtensionProps 11" (fun () -> foo.[true] <- "") "Setting Item(bool) string"
-        checkSet "ExtensionProps 13" (fun () -> foo.[true] <- true) "Setting Item(bool) bool"
-        checkSet "ExtensionProps 14" (fun () -> foo.[""] <- true) "Setting Item(string) bool"
-        
-        checkSet "ExtensionProps 16" (fun () -> foo.Prop("", "") <- "") "Setting Prop(string, string) string"
-        checkSet "ExtensionProps 17" (fun () -> foo.Prop("", true) <- "") "Setting Prop(string, bool) string"
-        checkSet "ExtensionProps 19" (fun () -> foo.Prop("", true) <- true) "Setting Prop(string, bool) bool"
-        checkSet "ExtensionProps 20" (fun () -> foo.Prop("", "") <- true) "Setting Prop(string, string) bool"
-        
-        checkSet "ExtensionProps 22" (fun () -> foo.Plain <- "") "Setting intrinsic plain"
-
-module AccessThisAsPartOfSUperClassConstruction1 = 
-    open System
-    type Z(x : obj) = class end
-
-    type X() as Y =
-      class
-       inherit Z(Y.x)
-       do
-         ()
-       [<DefaultValue>]
-       val mutable x : int
-      end
-
-
-module AccessThisAsPartOfSUperClassConstruction2 = 
-
-    module Test1 = 
-       open System
-       type Z(x : obj) = class end
-
-       type X() as Y =
-         class
-          inherit Z(Y.x)
-          do
-            ()
-          [<DefaultValue>]
-          val mutable x : int
-         end
-
-
-
-    module Test2 = 
-       open System
-       type Z(x : obj) = class end
-
-       type X() as Y =
-         class
-          inherit Z(Y.x)
-          do
-            ()
-          [<DefaultValue>]
-          val mutable x : int
-
-          member self.ThisPtr = Y
-         end
-
-    module Test3 = 
-       open System
-       type Z(x : obj) = class end
-
-       type X() as Y =
-         class
-          inherit Z(Y.x)
-          let getThis () = Y
-          do
-            ()
-          [<DefaultValue>]
-          val mutable x : int
-
-          member self.ThisPtr = getThis()
-         end
-
-    module Test4 = 
-       open System
-       type Z(x : obj) = class end
-
-       type X() as Y =
-         class
-          inherit Z(Y.x)
-          let ths = Y
-          do
-            ()
-          [<DefaultValue>]
-          val mutable x : int
-
-          member self.ThisPtr = ths
-         end
-
-
-
-
-    module GenericTest1 = 
-       open System
-       type Z(x : obj) = class end
-
-       type X<'T>() as Y =
-         class
-          inherit Z(Y.x)
-          do
-            ()
-          [<DefaultValue>]
-          val mutable x : int
-         end
-
-
-
-    module GenericTest2 = 
-       open System
-       type Z(x : obj) = class end
-
-       type X<'T>() as Y =
-         class
-          inherit Z(Y.x)
-          do
-            ()
-          [<DefaultValue>]
-          val mutable x : int
-
-          member self.ThisPtr = Y
-         end
-
-    module GenericTest3 = 
-       open System
-       type Z(x : obj) = class end
-
-       type X<'T>() as Y =
-         class
-          inherit Z(Y.x)
-          let getThis () = Y
-          do
-            ()
-          [<DefaultValue>]
-          val mutable x : int
-
-          member self.ThisPtr = getThis()
-         end
-
-    module GenericTest4 = 
-       open System
-       type Z(x : obj) = class end
-
-       type X<'T>() as Y =
-         class
-          inherit Z(Y.x)
-          let ths = Y
-          do
-            ()
-          [<DefaultValue>]
-          val mutable x : int
-
-          member self.ThisPtr = ths
-         end
-
-
-module AccessThisAsPartOfSUperClassConstruction3 = 
-
-    type B(obj:obj) = 
-        member x.P = 1
-
-    type C1() as a = 
-        inherit B((fun () -> a)) // captures 'this' as part of call to super class constructor
-        member x.P = 1
-        
-    type C2() as a = 
-        inherit B((fun () -> a)) // captures 'this' as part of call to super class constructor
-        member x.P = a // and captures it in a method
-
-
-module EqualityComparisonPositiveTests = 
-
-
-    module StructDefaultConstructorCantBeUsed =
-
-        [<Struct>]
-        type U1(v:int) = 
-            member x.P = v
-
-        let v1 = U1()  // can be used - expect no error
-
-
-    module BasicExample1 =
-        let f1 (x : list<int>) = (x = x) // expect ok
-        let f2 (x : option<int>) = (x = x) // expect ok
-        let f3 (x : Choice<int,int>) = (x = x) // expect ok
-        let f4 (x : Choice<int,int,int>) = (x = x) // expect ok
-        let f5 (x : Choice<int,int,int,int>) = (x = x) // expect ok
-        let f6 (x : Choice<int,int,int,int,int>) = (x = x) // expect ok
-        let f7 (x : Choice<int,int,int,int,int,int>) = (x = x) // expect ok
-        let f8 (x : Choice<int,int,int,int,int,int,int>) = (x = x) // expect ok
-        let f9 (x : ref<int>) = (x = x) // expect ok
-        let fq (x : Set<int>) = (x = x) // expect ok
-        let fw (x : Map<int,int>) = (x = x) // expect ok
-        
-        let fe (x : list<System.Type>) = (x = x) // expect ok
-        let fr (x : option<System.Type>) = (x = x) // expect ok
-        let ft (x : Choice<System.Type,int>) = (x = x) // expect ok
-        let fy (x : Choice<System.Type,int,int>) = (x = x) // expect ok
-        let fu (x : Choice<System.Type,int,int,int>) = (x = x) // expect ok
-        let fi (x : Choice<System.Type,int,int,int,int>) = (x = x) // expect ok
-        let fo (x : Choice<System.Type,int,int,int,int,int>) = (x = x) // expect ok
-        let fp (x : Choice<System.Type,int,int,int,int,int,int>) = (x = x) // expect ok
-        let fa (x : ref<System.Type>) = (x = x) // expect ok
-
-
-        let fn (x : Set<list<int>>) = () // expect ok
-        let fm (x : Set<option<int>>) = () // expect ok
-        let fQ (x : Set<ref<int>>) = () // expect ok
-        let fW (x : Set<Set<int>>) = () // expect ok
-        let fE (x : Set<Map<int,int>>) = () // expect ok
-        let fO (x : Set<int * int>) = () // expect ok
-        let fP (x : Set<int * int * int>) = () // expect ok
-        let fA (x : Set<int * int * int * int>) = () // expect ok
-        let fS (x : Set<int * int * int * int * int>) = () // expect ok
-        let fD (x : Set<int * int * int * int * int * int>) = () // expect ok
-        let fF (x : Set<int * int * int * int * int * int * int>) = () // expect ok
-        let fG (x : Set<int * int * int * int * int * int * int * int>) = () // expect ok
-        let fH (x : Set<int * int * int * int * int * int * int * int * int >) = () // expect ok
-        let fJ (x : Set<int * int * int * int * int * int * int * int * int * int>) = () // expect ok
-        let fK (x : Set<int * int * int * int * int * int * int * int * int * int * int>) = () // expect ok
-
-        type R<'T> = R of 'T * R<'T>
-        let r1 (x : Set<R<int>>) = () // expect ok
-        let r3 (x : R<int>) = (x = x) // expect ok
-        let r4 (x : R<System.Type>) = (x = x) // expect ok
-
-        //type R2<'T> = | R2 : 'T * R2<'T> -> R2<'T>
-        //let q1 (x : Set<R2<int>>) = () // expect ok
-        //let q3 (x : R2<int>) = (x = x) // expect ok
-        //let q4 (x : R2<System.Type>) = (x = x) // expect ok
-        
-    module Example1 =
-        type X<'T> = X of 'T
-
-        let f0 (x : Set<X<int>>) = ()  // expect ok
-        let f1 (x : Set<X<'T>>) = ()  // expect ok
-        let f3 (x : X<list<int>>) = (x = x) // expect ok
-        let f5 (x : X<list<System.Type>>) = (x = x) // expect ok
-
-    module Example1_Record =
-        type X<'T> = { r : 'T }
-
-        let f0 (x : Set<X<int>>) = ()  // expect ok
-        let f1 (x : Set<X<'T>>) = ()  // expect ok
-        let f3 (x : X<list<int>>) = (x = x) // expect ok
-        let f5 (x : X<list<System.Type>>) = (x = x) // expect ok
-
-    module Example1_Struct =
-        type X<'T> = struct val r : 'T  end
-
-        let f0 (x : Set<X<int>>) = ()  // expect ok
-        let f1 (x : Set<X<'T>>) = ()  // expect ok
-        let f3 (x : X<list<int>>) = (x = x) // expect ok
-        let f5 (x : X<list<System.Type>>) = (x = x) // expect ok
-
-    module Example1_StructImplicit =
-        [<Struct; StructuralComparison; StructuralEquality>]
-        type X<[<EqualityConditionalOn;ComparisonConditionalOn>] 'T>(r:'T) = struct member x.R = r  end
-
-        let f0 (x : Set<X<int>>) = ()  // expect ok
-        let f1 (x : Set<X<'T>>) = ()  // expect ok
-        let f3 (x : X<list<int>>) = (x = x) // expect ok
-        let f5 (x : X<list<System.Type>>) = (x = x) // expect ok
-
-    module Example1_StructImplicit2 =
-        [<Struct>]
-        type X<[<EqualityConditionalOn;ComparisonConditionalOn>] 'T>(r:'T) = struct member x.R = r  end
-
-        let f0 (x : Set<X<int>>) = ()  // expect ok
-        let f1 (x : Set<X<'T>>) = ()  // expect ok
-        let f3 (x : X<list<int>>) = (x = x) // expect ok
-        let f5 (x : X<list<System.Type>>) = (x = x) // expect ok
-
-    module Example2 = 
-        type X<'T> = X of list<'T>
-
-        let f0 (x : Set<X<int>>) = ()   // expect ok
-        let f1 (x : Set<X<'T>>) = ()   // expect ok
-
-        let f4 (x : X<list<int>>) = (x = x) // expect ok
-        let f6 (x : X<list<System.Type>>) = (x = x) // expect ok
-
-
-    module Example3 = 
-        type X<'T> = X of Y<'T>
-        and Y<'T> = Y of 'T
-
-        let f0 (x : Set<X<int>>) = ()   // expect ok
-        let f1 (x : Set<X<'T>>) = ()   // expect ok
-
-        let f4 (x : X<list<int>>) = (x = x) // expect ok
-        let f6 (x : X<list<System.Type>>) = (x = x) // expect ok
-
-    module Example4 = 
-        type X<'T> = X of Y<'T>
-        and Y<'T> = Y of 'T * X<'T>
-
-        let f0 (x : Set<X<int>>) = ()   // expect ok
-        let f1 (x : Set<X<'T>>) = ()   // expect ok
-
-        let f4 (x : X<list<int>>) = (x = x) // expect ok
-        let f6 (x : X<list<System.Type>>) = (x = x) // expect ok
-
-        let g0 (x : Set<Y<int>>) = ()   // expect ok
-        let g1 (x : Set<Y<'T>>) = ()   // expect ok
-
-        let g4 (x : Y<list<int>>) = (x = x) // expect ok
-        let g6 (x : Y<list<System.Type>>) = (x = x) // expect ok
-
-    module Example5 = 
-        type X<'T> = X of Y<'T>
-        and Y<'T> = Y of int
-
-        let f0 (x : Set<X<int>>) = ()   // expect ok
-        let f1 (x : Set<X<'T>>) = ()   // expect ok
-        let f2 (x : Set<X<System.Type>>) = () // expect ok
-        let f3 (x : Set<X<list<System.Type>>>) = () // expect ok
-
-        let f4 (x : X<list<int>>) = (x = x) // expect ok
-        let f5 (x : X<int -> int>) = (x = x) // expect ok
-        let f6 (x : X<list<System.Type>>) = (x = x) // expect ok
-        let f7 (x : X<list<int -> int>>) = (x = x) // expect ok
-
-        let g0 (x : Set<Y<int>>) = ()   // expect ok
-        let g1 (x : Set<Y<'T>>) = ()   // expect ok
-        let g2 (x : Set<Y<System.Type>>) = () // expect ok
-        let g3 (x : Set<Y<list<System.Type>>>) = () // expect ok
-
-        let g4 (x : Y<list<int>>) = (x = x) // expect ok
-        let g5 (x : Y<int -> int>) = (x = x) // expect ok
-        let g6 (x : Y<list<System.Type>>) = (x = x) // expect ok
-        let g7 (x : Y<list<int -> int>>) = (x = x) // expect ok
-
-    module Example6 = 
-        type X<'T> = X of Y<int,'T>
-        and Y<'T,'U> = Y of 'T * X<'T>
-
-        let f0 (x : Set<X<int>>) = ()   // expect ok
-        let f1 (x : Set<X<'T>>) = ()   // expect ok
-        let f2 (x : Set<X<System.Type>>) = () // expect ok
-        let f3 (x : Set<X<list<System.Type>>>) = () // expect ok
-
-        let f4 (x : X<list<int>>) = (x = x) // expect ok
-        let f5 (x : X<int -> int>) = (x = x) // expect ok
-        let f6 (x : X<list<System.Type>>) = (x = x) // expect ok
-        let f7 (x : X<list<int -> int>>) = (x = x) // expect ok
-
-        let g0 (x : Set<Y<int,int>>) = ()   // expect ok
-        let g1 (x : Set<Y<'T,'T>>) = ()   // expect ok
-
-        let g4 (x : Y<list<int>,int>) = (x = x) // expect ok
-        let g6 (x : Y<list<System.Type>, int>) = (x = x) // expect ok
-
-
-        let g8 (x : Y<int,list<int>>) = (x = x) // expect ok
-        let g9 (x : Y<int,(int -> int)>) = (x = x) // expect ok
-        let g10 (x : Y<int,list<System.Type>>) = (x = x) // expect ok
-        let g11 (x : Y<int,list<(int -> int)>>) = (x = x) // expect ok
-
-    module Example7 = 
-        // a type inferred to be without equality or comparison
-        type X = X of (int -> int)
-        // a type transitively inferred to be without equality or comparison
-        type  Y = Y of X
-
-
-    module Example8 = 
-        // a type inferred to be without comparison
-        type X = X of System.Type
-        // a type transitively inferred to be without comparison
-        type  Y = Y of X
-
-        let f2 (x : X) = (x = x) // expect ok
-        let f3 (x : Y) = (x = x) // expect ok
-
-
-module RuntimeCheckForSelfCallThroughProperty1 =  begin
-    [<AbstractClass>]
-    type Base(callIt:bool) as self = 
-       do if callIt then printfn "P = %d" self.P // expect an exception here
-       abstract P: int
-
-    type C(callIt:bool) = 
-       inherit Base(callIt)
-       let x = 1
-       override __.P = x
-
-    check "cewlkcnc332a" (try C(true) |> ignore; "ok" with :? System.InvalidOperationException -> "fail") "fail"
-    check "cewlkcnc332b" (try C(false) |> ignore; "ok" with :? System.InvalidOperationException -> "fail") "ok"
-end
-
-module RuntimeCheckForSelfCallThroughSetterProperty1 =  begin
-    [<AbstractClass>]
-    type Base(callIt:bool) as self = 
-       do if callIt then self.P <- 1  // expect an exception here
-       abstract P: int with set
-
-    type C(callIt:bool) = 
-       inherit Base(callIt)
-       let x = 1
-       override __.P with set v = ()
-
-    check "cewlkcnc332c" (try C(true) |> ignore; "ok" with :? System.InvalidOperationException -> "fail") "fail"
-    check "cewlkcnc332d" (try C(false) |> ignore; "ok" with :? System.InvalidOperationException -> "fail") "ok"
-end
-
-module RuntimeCheckForSelfCallThroughInterfaceSetterProperty1 =  begin
-    
-    type I = 
-       abstract P: int with set
-        
-    type Base(callIt:bool) as self = 
-       do if callIt then (box self :?> I).P <- 1  // expect an exception here
-
-    type C(callIt:bool) = 
-       inherit Base(callIt)
-       let x = 1
-       interface I with 
-           member __.P with set v = ()
-
-    check "cewlkcnc332y" (try C(true) |> ignore; "ok" with :? System.InvalidOperationException -> "fail") "fail"
-    check "cewlkcnc332t" (try C(false) |> ignore; "ok" with :? System.InvalidOperationException -> "fail") "ok"
-end
-
-
-module RuntimeCheckForSelfCallThroughProperty1ExplicitClass =  begin
-    [<AbstractClass>]
-    type Base = 
-       new (callIt: bool) as self = 
-           { } 
-           then 
-               if callIt then printfn "P = %d" self.P // expect an exception here
-
-       abstract P: int
-
-    type C = 
-       inherit Base
-       val x : int
-       new (callIt: bool) as self = { inherit Base(callIt); x = 1 }  
-       override __.P = x
-
-    check "explicit-cewlkcnc332a" (try C(true) |> ignore; "ok" with :? System.InvalidOperationException -> "fail") "fail"
-    check "explicit-cewlkcnc332b" (try C(false) |> ignore; "ok" with :? System.InvalidOperationException -> "fail") "ok"
-end
-
-module RuntimeCheckForSelfCallThroughSetterProperty1ExplicitClass =  begin
-    [<AbstractClass>]
-    type Base = 
-       new (callIt: bool) as self = 
-           { } 
-           then 
-               if callIt then self.P <- 1 // expect an exception here
-       abstract P: int with set
-
-    type C = 
-       inherit Base
-       val x : int
-       new (callIt: bool) as self = { inherit Base(callIt); x = 1 }  
-       override __.P with set v = ()
-
-    check "explicit-cewlkcnc332c" (try C(true) |> ignore; "ok" with :? System.InvalidOperationException -> "fail") "fail"
-    check "explicit-cewlkcnc332d" (try C(false) |> ignore; "ok" with :? System.InvalidOperationException -> "fail") "ok"
-end
-
-module RuntimeCheckForSelfCallThroughInterfaceSetterProperty1ExplicitClass =  begin
-    
-    type I = 
-       abstract P: int with set
-        
-    type Base = 
-       new (callIt: bool) as self = 
-           { } 
-           then 
-               if callIt then (box self :?> I).P <- 1 // expect an exception here
-
-
-    type C = 
-       inherit Base
-       val x : int
-       new (callIt: bool) as self = { inherit Base(callIt); x = 1 }  
-       interface I with 
-           member __.P with set v = ()
-
-    check "explicit-cewlkcnc332y" (try C(true) |> ignore; "ok" with :? System.InvalidOperationException -> "fail") "fail"
-    check "explicit-cewlkcnc332t" (try C(false) |> ignore; "ok" with :? System.InvalidOperationException -> "fail") "ok"
-end
-
-module PartiallyReimplementInheritedInterfaces = begin
-    //---------------------------------------------------
-    // Basic test 1
-
-    module BasicTest1 = 
-        type public I1 = 
-            abstract V1 : string 
-            
-        type public I2 = 
-            inherit I1 
-            abstract V2 : string 
-            
-        type public C1() = 
-            interface I1 with 
-                member this.V1 = "C1" 
-                
-        type public C2() = 
-            inherit C1() 
-            interface I2 with 
-                member this.V2 = "C2"         
-
-        type public C3() = 
-            inherit C1() 
-            interface I2 with 
-                member this.V1 = "C1b"         
-                member this.V2 = "C2b"         
-
-        check "8kvnvwe0-we1"  (C2() :> I2).V2 "C2"
-        check "8kvnvwe0-we2"  (C2() :> I1).V1 "C1"
-        check "8kvnvwe0-we3"  (C3() :> I1).V1 "C1b"
-
-    //---------------------------------------------------
-    // Basic test 3 - IEnumerable --> IEnumerable<int>
-
-
-    module InheritIEnumerableTest1 = 
-        open System.Collections
-        open System.Collections.Generic
-        type BaseCollection() = 
-            override __.GetHashCode() = 0
-            override __.Equals(yobj) = true
-            interface System.Collections.IEnumerator with 
-                member __.Reset() = ()
-                member __.Current = box 1
-                member __.MoveNext() = true
-                
-        type DerivedCollection() = 
-            inherit BaseCollection()
-            interface System.Collections.Generic.IEnumerator<int> with 
-                member __.Reset() = ()
-                member __.Current = 2
-                member __.Current = box 2
-                member __.Dispose() = ()
-                member __.MoveNext() = false
-
-
-        type ReDerivedCollection1() = 
-            inherit DerivedCollection()
-            interface System.Collections.Generic.IEnumerator<int> 
-
-        type ReDerivedCollection2() = 
-            inherit DerivedCollection()
-            interface System.Collections.IEnumerator
-
-        type ReDerivedCollection3() = 
-            inherit DerivedCollection()
-            interface System.IDisposable
-            interface System.Collections.IEnumerator
-
-        type ReDerivedCollection4() = 
-            inherit DerivedCollection()
-            interface System.IDisposable
-
-
-        check "8kvnvwe0-we4"  (new DerivedCollection() :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-we5"  ((new DerivedCollection() :> IEnumerator<int>).MoveNext()) false
-        check "8kvnvwe0-we6"  (new DerivedCollection() :> IEnumerator).Current (box 2)
-        check "8kvnvwe0-we7"  ((new DerivedCollection() :> IEnumerator).MoveNext()) false
-        check "8kvnvwe0-we8"  (new ReDerivedCollection1() :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-we9"  ((new ReDerivedCollection1() :> IEnumerator<int>).MoveNext()) false
-        check "8kvnvwe0-weq"  (new ReDerivedCollection2() :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-wew"  ((new ReDerivedCollection2() :> IEnumerator<int>).MoveNext()) false
-        check "8kvnvwe0-wee"  (new ReDerivedCollection3() :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-wer"  ((new ReDerivedCollection3() :> IEnumerator<int>).MoveNext()) false
-        check "8kvnvwe0-wet"  (new BaseCollection() :> IEnumerator).Current (box 1)
-        check "8kvnvwe0-wey"  ((new BaseCollection() :> IEnumerator).MoveNext()) true
-
-    module InheritIEnumerableTest2 = 
-        open System.Collections
-        open System.Collections.Generic
-        type BaseCollection() = 
-            override __.GetHashCode() = 0
-            override __.Equals(yobj) = true
-            interface System.Collections.IEnumerator with 
-                member __.Reset() = ()
-                member __.Current = box 1
-                member __.MoveNext() = true
-                
-        type DerivedCollection() = 
-            inherit BaseCollection()
-            interface System.Collections.Generic.IEnumerator<int> with 
-                // Emit one or more members to inherit implementations of some of the interfaces
-                //member __.Reset() = ()
-                member __.Current = 2
-                member __.Current = box 2
-                member __.Dispose() = ()
-                member __.MoveNext() = false
-
-        type ReDerivedCollection1() = 
-            inherit DerivedCollection()
-            interface System.Collections.Generic.IEnumerator<int> 
-
-        type ReDerivedCollection2() = 
-            inherit DerivedCollection()
-            interface System.Collections.IEnumerator
-
-        type ReDerivedCollection3() = 
-            inherit DerivedCollection()
-            interface System.IDisposable
-            interface System.Collections.IEnumerator
-
-        type ReDerivedCollection4() = 
-            inherit DerivedCollection()
-            interface System.IDisposable
-
-        check "8kvnvwe0-weu"  (new DerivedCollection() :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-wei"  ((new DerivedCollection() :> IEnumerator<int>).MoveNext()) false
-        check "8kvnvwe0-weo"  (new DerivedCollection() :> IEnumerator).Current (box 2)
-        check "8kvnvwe0-wep"  ((new DerivedCollection() :> IEnumerator).MoveNext()) false
-        check "8kvnvwe0-wea"  (new ReDerivedCollection1() :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-wes"  ((new ReDerivedCollection1() :> IEnumerator<int>).MoveNext()) false
-        check "8kvnvwe0-wed"  (new ReDerivedCollection2() :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-wef"  ((new ReDerivedCollection2() :> IEnumerator<int>).MoveNext()) false
-        check "8kvnvwe0-weg"  (new ReDerivedCollection3() :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-weh"  ((new ReDerivedCollection3() :> IEnumerator<int>).MoveNext()) false
-        check "8kvnvwe0-wej"  (new BaseCollection() :> IEnumerator).Current (box 1)
-        check "8kvnvwe0-wek"  ((new BaseCollection() :> IEnumerator).MoveNext()) true
-
-    module InheritIEnumerableTest3 = 
-        open System.Collections
-        open System.Collections.Generic
-        type BaseCollection() = 
-            override __.GetHashCode() = 0
-            override __.Equals(yobj) = true
-            interface System.Collections.IEnumerator with 
-                member __.Reset() = ()
-                member __.Current = box 1
-                member __.MoveNext() = true
-                
-        type DerivedCollection() = 
-            inherit BaseCollection()
-            interface System.Collections.Generic.IEnumerator<int> with 
-                // Emit one or more members to inherit implementations of some of the interfaces
-                //member __.Reset() = ()
-                member __.Current = 2
-                //member __.Current = box 1
-                member __.Dispose() = ()
-                member __.MoveNext() = false
-
-        type ReDerivedCollection1() = 
-            inherit DerivedCollection()
-            interface System.Collections.Generic.IEnumerator<int> 
-
-        type ReDerivedCollection2() = 
-            inherit DerivedCollection()
-            interface System.Collections.IEnumerator
-
-        type ReDerivedCollection3() = 
-            inherit DerivedCollection()
-            interface System.IDisposable
-            interface System.Collections.IEnumerator
-
-        type ReDerivedCollection4() = 
-            inherit DerivedCollection()
-            interface System.IDisposable
-
-        check "8kvnvwe0-wel"  (new DerivedCollection() :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-wez"  ((new DerivedCollection() :> IEnumerator<int>).MoveNext()) false
-        check "8kvnvwe0-wex"  (new DerivedCollection() :> IEnumerator).Current (box 1)
-        check "8kvnvwe0-wec"  ((new DerivedCollection() :> IEnumerator).MoveNext()) false
-        check "8kvnvwe0-wev"  (new ReDerivedCollection1() :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-web"  ((new ReDerivedCollection1() :> IEnumerator<int>).MoveNext()) false
-        check "8kvnvwe0-wen"  (new ReDerivedCollection2() :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-wem"  ((new ReDerivedCollection2() :> IEnumerator<int>).MoveNext()) false
-        check "8kvnvwe0-weQ"  (new ReDerivedCollection3() :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-weW"  ((new ReDerivedCollection3() :> IEnumerator<int>).MoveNext()) false
-        check "8kvnvwe0-weE"  (new BaseCollection() :> IEnumerator).Current (box 1)
-        check "8kvnvwe0-weR"  ((new BaseCollection() :> IEnumerator).MoveNext()) true
-
-    module InheritIEnumerableTest4 = 
-        open System.Collections
-        open System.Collections.Generic
-        type BaseCollection() = 
-            override __.GetHashCode() = 0
-            override __.Equals(yobj) = true
-            interface System.Collections.IEnumerator with 
-                member __.Reset() = ()
-                member __.Current = box 1
-                member __.MoveNext() = true
-                
-        type DerivedCollection() = 
-            inherit BaseCollection()
-            interface System.Collections.Generic.IEnumerator<int> with 
-                // Emit one or more members to inherit implementations of some of the interfaces
-                //member __.Reset() = ()
-                member __.Current = 2
-                //member __.Current = box 1
-                member __.Dispose() = ()
-                //member __.MoveNext() = true
-
-        type ReDerivedCollection1() = 
-            inherit DerivedCollection()
-            interface System.Collections.Generic.IEnumerator<int> 
-
-        type ReDerivedCollection2() = 
-            inherit DerivedCollection()
-            interface System.Collections.IEnumerator
-
-        type ReDerivedCollection3() = 
-            inherit DerivedCollection()
-            interface System.IDisposable
-            interface System.Collections.IEnumerator
-
-        type ReDerivedCollection4() = 
-            inherit DerivedCollection()
-            interface System.IDisposable
-
-
-        check "8kvnvwe0-weT"  (new DerivedCollection() :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-weY"  ((new DerivedCollection() :> IEnumerator<int>).MoveNext()) true
-        check "8kvnvwe0-weU"  (new DerivedCollection() :> IEnumerator).Current (box 1)
-        check "8kvnvwe0-weI"  ((new DerivedCollection() :> IEnumerator).MoveNext()) true
-        check "8kvnvwe0-weO"  (new ReDerivedCollection1() :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-weP"  ((new ReDerivedCollection1() :> IEnumerator<int>).MoveNext()) true
-        check "8kvnvwe0-weA"  (new ReDerivedCollection2() :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-weS"  ((new ReDerivedCollection2() :> IEnumerator<int>).MoveNext()) true
-        check "8kvnvwe0-weD"  (new ReDerivedCollection3() :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-weF"  ((new ReDerivedCollection3() :> IEnumerator<int>).MoveNext()) true
-        check "8kvnvwe0-weG"  (new BaseCollection() :> IEnumerator).Current (box 1)
-        check "8kvnvwe0-weH"  ((new BaseCollection() :> IEnumerator).MoveNext()) true
-
-    // Add some generics
-    module InheritIEnumerableTest5 = 
-        open System.Collections
-        open System.Collections.Generic
-        type BaseCollection<'T>(x:'T) = 
-            override __.GetHashCode() = 0
-            override __.Equals(yobj) = true
-            interface System.Collections.IEnumerator with 
-                member __.Reset() = ()
-                member __.Current = box x
-                member __.MoveNext() = true
-                
-        type DerivedCollection<'U>(x:'U) = 
-            inherit BaseCollection<'U>(x)
-            interface System.Collections.Generic.IEnumerator<'U> with 
-                // Emit one or more members to inherit implementations of some of the interfaces
-                //member __.Reset() = ()
-                member __.Current = x
-                //member __.Current = box 1
-                member __.Dispose() = ()
-                //member __.MoveNext() = true
-
-        type ReDerivedCollection1() = 
-            inherit DerivedCollection<int>(3)
-            interface System.Collections.Generic.IEnumerator<int> 
-
-        type ReDerivedCollection2() = 
-            inherit DerivedCollection<string>("4")
-            interface System.Collections.IEnumerator
-
-        type ReDerivedCollection3() = 
-            inherit DerivedCollection<uint32>(3u)
-            interface System.IDisposable
-            interface System.Collections.IEnumerator
-
-        type ReDerivedCollection4<'T>(x:'T) = 
-            inherit DerivedCollection<'T>(x)
-            interface System.IDisposable
-
-
-        check "8kvnvwe0-weJ"  (new DerivedCollection<int>(2) :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-weK"  ((new DerivedCollection<int>(2) :> IEnumerator<int>).MoveNext()) true
-        check "8kvnvwe0-weL"  (new DerivedCollection<int>(1) :> IEnumerator).Current (box 1)
-        check "8kvnvwe0-weZ"  ((new DerivedCollection<int>(1) :> IEnumerator).MoveNext()) true
-        check "8kvnvwe0-weX"  (new ReDerivedCollection1() :> IEnumerator<int>).Current 3
-        check "8kvnvwe0-weC"  ((new ReDerivedCollection1() :> IEnumerator<int>).MoveNext()) true
-        check "8kvnvwe0-weV"  (new ReDerivedCollection2() :> IEnumerator<string>).Current "4"
-        check "8kvnvwe0-weB"  ((new ReDerivedCollection2() :> IEnumerator<string>).MoveNext()) true
-        check "8kvnvwe0-weN"  (new ReDerivedCollection3() :> IEnumerator<uint32>).Current 3u
-        check "8kvnvwe0-weM"  ((new ReDerivedCollection3() :> IEnumerator<uint32>).MoveNext()) true
-        check "8kvnvwe1-weq"  (new BaseCollection<int>(1) :> IEnumerator).Current (box 1)
-        check "8kvnvwe1-wWw"  ((new BaseCollection<int>(1) :> IEnumerator).MoveNext()) true
-
-    // Add some units of measure
-    module InheritIEnumerableTest6 = 
-        [<Measure>] type kg
-        
-        type BaseCollection<'T>(x:'T) = 
-            override __.GetHashCode() = 0
-            override __.Equals(yobj) = true
-            interface System.Collections.IEnumerator with 
-                member __.Reset() = ()
-                member __.Current = box x
-                member __.MoveNext() = true
-                
-        type DerivedCollection<'U>(x:'U) = 
-            inherit BaseCollection<'U>(x)
-            interface System.Collections.Generic.IEnumerator<'U> with 
-                // Emit one or more members to inherit implementations of some of the interfaces
-                //member __.Reset() = ()
-                member __.Current = x
-                //member __.Current = box 1
-                member __.Dispose() = ()
-                //member __.MoveNext() = true
-
-        type ReDerivedCollection1() = 
-            inherit DerivedCollection<int<kg>>(3<kg>)
-            interface System.Collections.Generic.IEnumerator<int<kg>> 
-
-        type ReDerivedCollection2() = 
-            inherit DerivedCollection<float<kg>>(4.0<kg>)
-            interface System.Collections.IEnumerator
-
-        type ReDerivedCollection3() = 
-            inherit DerivedCollection<int64<kg>>(3L<kg>)
-            interface System.IDisposable
-            interface System.Collections.IEnumerator
-
-        type ReDerivedCollection4<'T>(x:'T) = 
-            inherit DerivedCollection<'T>(x)
-            interface System.IDisposable
-
-        type ReDerivedCollection5<'T>(x:'T) = 
-            inherit ReDerivedCollection3()
-            interface System.IDisposable
-            interface System.Collections.Generic.IEnumerator<int64<kg>> 
-
-
-        check "8kvnvwe0-weJ"  (new DerivedCollection<int>(2) :> IEnumerator<int>).Current 2
-        check "8kvnvwe0-weK"  ((new DerivedCollection<int>(2) :> IEnumerator<int>).MoveNext()) true
-        check "8kvnvwe0-weL"  (new DerivedCollection<int>(1) :> IEnumerator).Current (box 1)
-        check "8kvnvwe0-weZ"  ((new DerivedCollection<int>(1) :> IEnumerator).MoveNext()) true
-        check "8kvnvwe0-weX"  (new ReDerivedCollection1() :> IEnumerator<int<kg>>).Current 3<kg>
-        check "8kvnvwe0-weC"  ((new ReDerivedCollection1() :> IEnumerator<int<kg>>).MoveNext()) true
-        check "8kvnvwe0-weV"  (new ReDerivedCollection2() :> IEnumerator<float<kg>>).Current 4.0<kg>
-        check "8kvnvwe0-weB"  ((new ReDerivedCollection2() :> IEnumerator<float<kg>>).MoveNext()) true
-        check "8kvnvwe0-weN"  (new ReDerivedCollection3() :> IEnumerator<int64<kg>>).Current 3L<kg>
-        check "8kvnvwe0-weM"  ((new ReDerivedCollection3() :> IEnumerator<int64<kg>>).MoveNext()) true
-        check "8kvnvwe1-weq"  (new BaseCollection<int>(1) :> IEnumerator).Current (box 1)
-        check "8kvnvwe1-wWw"  ((new BaseCollection<int>(1) :> IEnumerator).MoveNext()) true
-
-end
-
-module ClassWithInheritAndImmediateReferenceToThisInLet = 
-    type B() = 
-        member __.P = 1
-
-    let id x = x
-
-    type C() as x = 
-        inherit B()
-        let y = id x // it is ok to access the this pointer and pass it to external code as long as it doesn't call any members
-        member __.ThisPointer1 = x
-        member __.ThisPointer2 = y
-
-
-    let checkA() = 
-        let c = C()
-        check "cwknecw021" c.ThisPointer1 c.ThisPointer2
-   
-module ClassWithNoInheritAndImmediateReferenceToThisInLet = 
-    type C() as x = 
-        let y = id x // it is ok to access the this pointer and pass it to external code as long as it doesn't call any members
-        member __.ThisPointer1 = x
-        member __.ThisPointer2 = y
-
-
-    let checkB() = 
-        let c = C()
-        check "cwknecw021b" c.ThisPointer1 c.ThisPointer2
-
-
-module CheckResolutionOrderForMembers1 = 
-    type System.String with 
-        static member M1 () = 1
-        static member M1 (?s : string) = 2
-    let a = System.String.M1()
-    check "vew98vrknj1" a 1
-    
-module CheckResolutionOrderForMembers2 = 
-    type System.String with 
-        static member M1 (?s : string) = 2
-        static member M1 () = 1
-
-    let b = System.String.M1()
-    
-    check "vew98vrknj2" b 1
-
-module CheckResolutionOrderForMembers3 = 
-    type C = 
-        static member M1 () = 1
-        static member M1 (?s : string) = 2
-
-    let a1 = C.M1()
-    let a2 = C.M1("2")
-    check "vew98vrknj3" a1 1
-    check "vew98vrknj3" a2 2
-
+module StaticInitializerTest3 =
 
-module CheckUsesOfNonOverloadMembersAssertReturnTypeBeforeCheckingArgs = 
+    let x = ref 2
+    do x := 3
 
     type C() = 
-        static member M(x:int)  = 0
-        static member M(x:string) = 1
-
-        member __.N(x:int)  = 0
-        member __.N(x:string) = 1
-
-    let test (x:int) = 1
-    type D() = 
-        static member Test (x:int) = 1
-
-
-    // In this case, the overload C.M resolves, because the return type of 
-    // loopX is known, from the return type of test.
-
-    let rec loopX() = test (C.M(loopX()))  
-
-    // In this case, the overload C.M resolves, because the return type of 
-    // loopY is known, from the return type of test.
-
-    let rec loopY() = D.Test (C.M(loopY()))  
-
-    // Instance member versions of the same
-    let c = C()
-    let rec loopX1() = test (c.N(loopX1()))  
-    let rec loopY1() = D.Test (c.N(loopY1()))  
-
-
-// Believe it or not, this caused the type checker to loop (bug 5803)
-module BasicTypeCHeckingLoop = 
-
-
-    type Vector() =
-        static member (+)(v1:Vector,v2) = 0
-
-    let foo (v1:Vector) v2 : int = v1 + v2
-
-module CheckGeneralizationOfMembersInRecursiveGroupsWhichIncludeImplicitConstructors = 
-
-    open System.Collections
-    open System.Collections.Generic
-
-    type IA<'T> = interface abstract M2 : int -> int end
-
-    type X<'T>() =
-        let mutable redirectTo : X<'T> = Unchecked.defaultof<_>
-
-        member x.M1() = if true then redirectTo else x
-        member x.M2() = if true then redirectTo else x
-        interface IA<int> with
-            member x.M2 y = y
-
-
-    [<Struct>]
-    type S<'T>(redirectTo : list<S<'T>>) =
-
-        member x.M() = if true then redirectTo.[0] else x
-
-
-    module Issue3Minimal = 
-        type MyDiscrUnion<'t> =
-            | MyCase of MyConstructedClass<'t>  
-
-            member this.M() =
-                match this with
-                | MyCase r -> r.Record
-        and MyConstructedClass<'t>( record : MyDiscrUnion<'t> ) = 
-           member x.Record = record
-
-    module Issue4 = 
-        type MyDiscrUnion<'t> =
-            | MyCase       of MyConstructedClass<'t>  
-            member x.Value (t : 't) =
-                match x with
-                | MyCase       r -> r.Apply t
-        and MyConstructedClass<'t>( foo : 't ) = 
-            member x.Apply ( t: 't ) = t
-
-    type ClassA<'t>(b: ClassB<'t>, c:'t) =
-        member x.A() = b.A() 
-    and ClassB<'t>( a : ClassA<'t> ) = 
-       member x.A()  = a
-
-module CheckGeneralizationOfMembersInRecursiveGroupsWhichIncludeImplicitConstructorsPart2 = 
-
-    // This test raised a code generation assert
-    module DontGeneralizeTypeVariablesBoundByInnerPositions_1 = 
-        type C() =  
-            let someFuncValue = C.Meth2() // someFuncValue initially has variable type. This type is not generalized.
-            static member Meth2() = C.Meth2() 
-        and C2() =
-            static member Meth1() = C.Meth2()
-
-    // This test raised a code generation assert
-    module DontGeneralizeTypeVariablesBoundByInnerPositions_2 = 
-        type C<'T>() =  
-            let someFuncValue = C<'T>.Meth2() // someFuncValue initially has variable type. This type is not generalized.
-            static member Meth2() = C<'T>.Meth2() 
-        and C2<'T>() =
-            static member Meth1() = C<'T>.Meth2()
-
-    // This test is a trimmed down version of a regression triggered by this fix
-    module M0 = 
-        type C<'T>(orig : 'T) =  
-            [<DefaultValue(false)>] 
-            val mutable parent : C<'T> 
-            let MyFind(x : C<'T>) = x.parent 
-            member this.Find() = MyFind(this) 
-
-    // This test is a trimmed down version of a regression triggered by this fix
-    module M1 = 
-        type C<'T>(orig : 'T) as this =  
-            [<DefaultValue(false)>] 
-            val mutable parent : C<'T> 
-            let MyFind(x : C<'T>) = x.parent 
-            member this.Find() = MyFind(this) 
-
-    // This test is an adapted version of the above trim-down
-    module M2 = 
-        type C<'T>(orig : 'T) as this =  
-            [<DefaultValue(false)>] 
-            val mutable parent : C2<'T> 
-            let MyFind(x : C<'T>) = (x.parent , x.parent.parent)
-            member this.Find() = MyFind(this) 
-        and C2<'T>(orig : 'T) as this =  
-            [<DefaultValue(false)>] 
-            val mutable parent : C<'T> 
-            let MyFind(x : C2<'T>) = (x.parent , x.parent.parent)
-            member this.Find() = MyFind(this) 
-
-    // This test is an adapted version of the above trim-down
-    module M3 = 
-        type C<'T>(orig : 'T) =  
-            [<DefaultValue(false)>] 
-            val mutable parent : C2<'T> 
-            let MyFind(x : C<'T>) = (x.parent , x.parent.parent)
-            member this.Find() = MyFind(this) 
-        and C2<'T>(orig : 'T) =  
-            [<DefaultValue(false)>] 
-            val mutable parent : C<'T> 
-            let MyFind(x : C2<'T>) = (x.parent , x.parent.parent)
-            member this.Find() = MyFind(this) 
-
-    // These are variations on tests where a cycle of methods and "let" bindings across one or more test is an adapted version of the above trim-down
-    module RoundInCircles = 
-        type C<'T>() as this =  
-            let someFuncValue = (); (fun ()  -> 
-                 this.Prop1() |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this))
-            let someFunc1() = 
-                 someFuncValue() |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this) 
-            let rec someFunc2() = 
-                 someFunc2() |> ignore;
-                 someFunc1() 
-            member this.Meth1() = someFunc2()
-            static member Meth2(this:C<'T>) = this.Meth1()
-            member this.Prop1 = (); (fun ()  -> 
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this))
-
-    // Mutual recursion between two generic classes
-    module RoundInCircles2 = 
-        type C<'T>() as this =  
-            let someFuncValue = (); (fun ()  -> 
-                 this.Prop1() |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this))
-            let someFunc1() = 
-                 someFuncValue() |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this) 
-            let rec someFunc2() = 
-                 someFunc2() |> ignore;
-                 someFunc1() 
-            member this.Meth1() = someFunc2()
-            static member Meth2(this:C<'T>) = this.Meth1()
-            member this.Prop1 = (); (fun ()  -> 
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this))
-        and C2<'T>(x:C<'T>) as this =  
-            let someFuncValue = (); (fun ()  -> 
-                 this.Prop1() |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(x))
-            let someFunc1() = 
-                 someFuncValue() |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(x) 
-            let rec someFunc2() = 
-                 someFunc2() |> ignore;
-                 someFunc1() 
-            member this.Meth1() = someFunc2()
-            static member Meth2(this:C<'T>) = this.Meth1()
-            member this.Prop1 = (); (fun ()  -> 
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(x))
-
-
-    // Mutual recursion between generic class and generic record type
-    module RoundInCircles3 = 
-        type C<'T>() as this =  
-            let someFuncValue = (); (fun ()  -> 
-                 this.Prop1() |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this))
-            let someFunc1() = 
-                 someFuncValue() |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this) 
-            let rec someFunc2() = 
-                 someFunc2() |> ignore;
-                 someFunc1() 
-            member this.Meth1() = someFunc2()
-            static member Meth2(this:C<'T>) = this.Meth1()
-            member this.Prop1 = (); (fun ()  -> 
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this))
-        and C2<'T> =
-            { x:C<'T> } 
-            member this.Meth1() = 
-                 this.Prop1() |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this.x)
-            static member Meth2(this:C<'T>) = this.Meth1()
-            member this.Prop1 = (); (fun ()  -> 
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this.x))
-
-    // Mutual recursion between generic class and generic union type
-    module RoundInCircles4 = 
-        type C<'T>() as this =  
-            let someFuncValue = (); (fun ()  -> 
-                 this.Prop1() |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this))
-            let someFunc1() = 
-                 someFuncValue() |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this) 
-            let rec someFunc2() = 
-                 someFunc2() |> ignore;
-                 someFunc1() 
-            member this.Meth1() = someFunc2()
-            static member Meth2(this:C<'T>) = this.Meth1()
-            member this.Prop1 = (); (fun ()  -> 
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this))
-        and C2<'T> =
-            | Parition2 of C<'T> 
-            member this.Value =  match this with Parition2 x -> x
-            member this.Meth1() = 
-                 this.Prop1() |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this.Value)
-            static member Meth2(this:C<'T>) = this.Meth1()
-            member this.Prop1 = (); (fun ()  -> 
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this.Value))
-
-    // Mutual recursion between generic class and generic union type, slight variation passing 'this' explicitly
-    module RoundInCircles5 = 
-        type C<'T>() =  
-            let someFuncValue = (); (fun (this:C<'T>)  -> 
-                 this.Prop1() |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this))
-            let someFunc1 this = 
-                 someFuncValue this |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this) 
-            let rec someFunc2 this = 
-                 someFunc2 this |> ignore;
-                 someFunc1 this
-            member this.Meth1() = someFunc2 this
-            static member Meth2(this:C<'T>) = this.Meth1()
-            member this.Prop1 = (); (fun ()  -> 
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this))
-        and C2<'T> =
-            | Parition2 of C<'T> 
-            member this.Value =  match this with Parition2 x -> x
-            member this.Meth1() = 
-                 this.Prop1() |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this.Value)
-            static member Meth2(this:C<'T>) = this.Meth1()
-            member this.Prop1 = (); (fun ()  -> 
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this.Value))
-
-    // Mutual recursion between generic class and generic struct
-    module RoundInCircles6 = 
-        type C<'T>() as this =  
-            let someFuncValue = (); (fun ()  -> 
-                 this.Prop1() |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this))
-            let someFunc1() = 
-                 someFuncValue() |> ignore
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this) 
-            let rec someFunc2() = 
-                 someFunc2() |> ignore;
-                 someFunc1() 
-            member this.Meth1() = someFunc2()
-            static member Meth2(this:C<'T>) = this.Meth1()
-            member this.Prop1 = (); (fun ()  -> 
-                 this.Meth1() |> ignore
-                 C<'T>.Meth2(this))
-        and C2<'T>(x:C<'T>) =  
-            struct
-                member this.Value = x
-                member this.Meth1() = x.Meth1()
-                static member Meth2(this:C<'T>) = this.Meth1()
-                member this.Prop1 = let v = this in (); (fun ()  -> 
-                     v.Meth1() |> ignore
-                     C<'T>.Meth2(v.Value))
-            end
-
-module CheckGeneralizationOfMembersInRecursiveGroupsWhichIncludeImplicitConstructorsAndStaticMembers = 
-
-    open System.Collections
-    open System.Collections.Generic
-
-    type IA<'T> = interface abstract M2 : int -> int end
-
-    type X<'T>() =
-        let mutable redirectTo : X<'T> = Unchecked.defaultof<_>
-        static let instance = X<'T>()
-        static member Instance = instance
-        member x.M1() = if true then redirectTo else x
-        member x.M2() = if true then redirectTo else x
-        interface IA<int> with
-            member x.M2 y = y
-
-
-    [<Struct>]
-    type S<'T>(redirectTo : list<S<'T>>) =
-        static let instance = S<'T>(List.empty<S<'T>>)
-        static member Instance = instance
-        member x.M() = if true then redirectTo.[0] else x
-
-
-    // This test raised a code generation assert
-    module DontGeneralizeTypeVariablesBoundByInnerPositions_2 = 
-        type C<'T>() =  
-            static let someStaticFuncValue = C<'T>.Meth2()
-            let someFuncValue = C<'T>.Meth2() // someFuncValue initially has variable type. This type is not generalized.
-            static member SomeStaticFuncValue = someStaticFuncValue            
-            static member Meth2() = C<'T>.Meth2() 
-        and C2<'T>() =
-            static member Meth1() = C<'T>.Meth2()
-
-    module Misc = 
-    
-        type Foo<'a>() =
-          static let theInstance = new Foo<'a>()
-          static member Instance = theInstance
-          
-        type Bar<'a,'b>() =
-          static let theInstance = new Bar<'a,'b>()
-          static member Instance = theInstance
-          
-        // Equi-recursive type defs
-        type Rec1<'a>() = 
-          static let rec2Instance = new Rec2<'a>()
-          static let rec1Instance = new Rec1<'a>()  
-          static member Rec2Instance = rec2Instance
-          static member Rec1Instance = rec1Instance
-        
-        and Rec2<'a>() =
-          static let rec1Instance = new Rec1<'a>()
-          static let rec2Instance = new Rec2<'a>()
-          static member Rec1Instance = rec1Instance
-          static member Rec2Instance = rec2Instance   
-          
-        // recursive type defs - multi tyargs
-        type Rec1AB<'a,'b>() = 
-          static let rec2Instance = new Rec2B<'a>()
-          static let rec1Instance = new Rec1AB<'a,'b>()  
-          static member Rec2Instance = rec2Instance
-          static member Rec1Instance = rec1Instance
-        
-        and Rec2B<'a>() =
-          static let rec2Instance = new Rec2B<'a>()
-          static member Rec2Instance = rec2Instance     
-          
-        // functions
-        type FooFunc<'a>() =
-            static let fact() = new FooFunc<'a>()
-            static member factory() = fact()
+        static let mutable v = x.Value + 1
+        static do v <- 3
         
-        // test methods    
-        type FooFunc2<'a>() =
-            static let fact = new FooFunc2<'a>()
-            static member factory() = fact
-                        
-        type BerFunc<'a,'b>() =
-          static let fact() = new BerFunc<'a,'b>()
-          static member factory() = fact()
-          
-        // Equi-recursive type defs
-        type Rec1Func<'a>() = 
-          static let rec2Instance() = new Rec2Func<'a>()
-          static let rec1Instance() = new Rec1Func<'a>()  
-          static member Rec2Instance() = rec2Instance()
-          static member Rec1Instance() = rec1Instance()        
-        and Rec2Func<'a>() =
-          static let rec1Instance() = new Rec1Func<'a>()
-          static let rec2Instance() = new Rec2Func<'a>()
-          static member Rec1Instance() = rec1Instance()
-          static member Rec2Instance() = rec2Instance()
-          
-        // recursive type defs - multi tyargs
-        type Rec1ABFunc<'a,'b>() = 
-          static let rec2Instance() = new Rec2BFunc<'a>()
-          static let rec1Instance() = new Rec1ABFunc<'a,'b>()  
-          static member Rec2Instance() = rec2Instance()
-          static member Rec1Instance() = rec1Instance()        
-        and Rec2BFunc<'a>() =
-          static let rec2Instance() = new Rec2BFunc<'a>()
-          static member Rec2Instance() = rec2Instance()
-
-module Devdiv2_Bug_41009 = 
-    type Rope<'T> = 
-        { x : int }
-        member x.Empty  : Rope<_> = failwith "" // the type variable for "_" is ungeneralized because this is a property
-        member x.Create(lhs:Rope<'T>) : Rope<'T> =
-            x.Empty  // here the type variable for "_" gets instantiated to 'T, but this gets generalized. This must not be considered an escaping variable
-
-
-module Devdiv2_Bug_10649 = 
-
-    // This should compile, because it compiles with F# 2.0. A has been generalized too early, 
-    // but all recursive uses of the member end up consistent with the final inferred type
-    module InstanceMembersEarlyGeneralizationPotentiallyInvalidButUltimatelyConsistent = 
-        type C<'T>() = 
-            let mutable x = Unchecked.defaultof<_> // this inference variable ultimately becomes 'obj'
-            member this.A() = x
-            member this.B1(c:C<string>) = c.A() 
-            member this.B2(c:C<int>) = c.A() 
-
-    // This should compile, because it compiles with F# 2.0. A has been generalized too early, 
-    // but all recursive uses of the member end up consistent with the final inferred type
-    module StaticMembersEarlyGeneralizationPotentiallyInvalidButUltimatelyConsistent = 
-        type C<'T>() = 
-            static let mutable x = Unchecked.defaultof<_> // this inference variable ultimately becomes 'obj'
-            static member A() = x
-            static member B1() = C<string>.A()
-            static member B2() = C<int>.A()
-
-    // This should compile, because it early generalization is valid for A
-    module InstanceMembersEarlyGeneralizationValid = 
-        type C<'T>() = 
-            member this.A() = 1
-            member this.B1(c:C<string>) = c.A() 
-            member this.B2(c:C<int>) = c.A() 
-
-    // This should compile, because it early generalization is valid for A
-    module StaticMembersEarlyGeneralizationValid = 
-        type C<'T>() = 
-            static member A() = 1
-            static member B1() = C<string>.A()
-            static member B2() = C<int>.A()
-
-
-module Devdiv2_Bug_5385 =
-    let memoize (f: 'a -> 'b) = 
-        let t = new System.Collections.Generic.Dictionary<'a, 'b>()
-        fun n ->
-            if t.ContainsKey(n) then 
-                t.[n]
-            else
-                let res = f n
-                t.[n] <- res
-                res
-
-    // In this variation, 
-    //     -- 'f' is generic even though it is in the same mutually recursive group as the computed function 'g', because although 'f' calls 'g', its type doesn't involve any type from 'g'
-    //     -- 'g' is not generic since 'g' is computed
-    let test3e () =
-        let count = ref 0
-        let rec f (x: 'T) =  
-                incr count; 
-                if !count > 4 then 
-                    1 
-                else 
-                    g "1" |> ignore; // note, use of non-generic 'g' within a generic, generalized memoized function
-                    2
-
-        and g : string -> int = memoize f // note, computed function value using generic �f� at an instance
-        g "1"                                        
-
-    let res = test3e()
-
-    check "fe09ekn" res 2
-
-    printfn "test passed ok without NullReferenceException"
-
-module Devdiv2_5385_repro2 = 
-
-    open System
-    type Dispatch<'t, 'a> = 't -> ('t -> Lazy<'a>) -> 'a 
-
-    let internal driver (mkString : 't -> string) (dispatch : Dispatch<'t, 'a>) (t : 't) : 'a = 
-            let rec driver2 (seen : Map<string,Lazy<'a>>) (t : 't) : Lazy<'a> = 
-                let tKey = mkString t 
-                let find = seen.TryFind tKey 
-                match find with 
-                    | Some x -> x 
-                    | None -> 
-                        let rec seen2 = seen.Add(tKey,res) 
-                            and res = lazy dispatch t (driver2 seen2) 
-                        res 
-            (driver2 (Map.empty) t).Value 
-
-
-
-    let res : int = driver (fun t -> t.ToString()) (fun t f -> if t > 50 then (f (t/2)).Value else t) 100 
-
-    check "kjnecwwe9" res 50
-
-    printfn "test passed ok without NullReferenceException"
+        member x.P = v
+        static member P2 = v+x.Value
 
+    check "lwnohivq16" (new C()).P 3
+    check "lwnohivq48" C.P2 6
 
 let _ = 
   if not failures.Value.IsEmpty then (eprintfn "Test Failed, failures = %A" failures.Value; exit 1) 
diff --git a/tests/fsharp/optimize/stats/ILLink.LinkAttributes.xml b/tests/fsharp/optimize/stats/ILLink.LinkAttributes.xml
new file mode 100644
index 00000000000..70eba54ff4e
--- /dev/null
+++ b/tests/fsharp/optimize/stats/ILLink.LinkAttributes.xml
@@ -0,0 +1,173 @@
+<linker>
+  <!--
+    Attributes listed below here should be behind the 'System.AggressiveAttributeTrimming' feature switch, which
+    is only enabled by default on app models that need as much size savings as possible.
+  -->
+  <assembly fullname="FSharp.Core" feature="System.AggressiveAttributeTrimming" featurevalue="true">
+    <!-- Microsoft.FSharp.Core -->
+    <type fullname="Microsoft.FSharp.Core.AbstractClassAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.AutoOpenAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.AutoSerializableAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.ClassAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.CLIEventAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.CLIMutableAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.ComparisonConditionalOnAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.CompilationArgumentCountsAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.CompilationSourceNameAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.CompiledNameAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.CompilerMessageAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.CustomComparisonAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.CustomEqualityAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.CustomOperationAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.DefaultAugmentationAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.DefaultValueAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.EntryPointAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.EqualityConditionalOnAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.ExperimentalAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.FSharpInterfaceDataVersionAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.GeneralizableValueAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.InlineIfLambdaAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.FSharpInterfaceDataVersionLiteralAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.MeasureAnnotatedAbbreviationAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.MeasureAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.NoComparisonAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.NoCompilerInliningAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.NoDynamicInvocationAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.NoEqualityAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.OptionalArgumentAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.ProjectionParameterAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.ReferenceEqualityAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.ReflectedDefinitionAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.RequireQualifiedAccessAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.RequiresExplicitTypeArgumentsAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.SealedAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.StructAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.StructuralComparisonAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.StructuralEqualityAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.TailCallAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.UnverifiableAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.ValueAsStaticPropertyAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.VolatileFieldAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+
+    <!-- The following attributes are accessed by FSharp.Core at runtime.
+    Removing them would cause behavior changes but the feature switch allows them. -->
+    <type fullname="Microsoft.FSharp.Core.AllowNullLiteralAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.CompilationMappingAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.CompilationRepresentationAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.StructuredFormatDisplayAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+
+    <!-- Microsoft.FSharp.Core.CompilerServices -->
+    <type fullname="Microsoft.FSharp.Core.CompilerServices.NoEagerConstraintApplicationAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.CompilerServices.TypeProviderAssemblyAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.CompilerServices.TypeProviderAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.CompilerServices.TypeProviderDefinitionLocationAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.CompilerServices.TypeProviderEditorHideMethodsAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+    <type fullname="Microsoft.FSharp.Core.CompilerServices.TypeProviderXmlDocAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
+  </assembly>
+</linker>
diff --git a/tests/fsharp/optimize/stats/ILLink.Substitutions.xml b/tests/fsharp/optimize/stats/ILLink.Substitutions.xml
new file mode 100644
index 00000000000..42d44a0b4c4
--- /dev/null
+++ b/tests/fsharp/optimize/stats/ILLink.Substitutions.xml
@@ -0,0 +1,8 @@
+<linker>
+  <assembly fullname="FSharp.Core">
+    <resource name="FSharpOptimizationCompressedData.FSharp.Core" action="remove" />
+    <resource name="FSharpOptimizationInfo.FSharp.Core" action="remove" />
+    <resource name="FSharpSignatureCompressedData.FSharp.Core" action="remove" />
+    <resource name="FSharpSignatureInfo.FSharp.Core" action="remove" />
+  </assembly>
+</linker>
diff --git a/tests/fsharpqa/Source/CompilerOptions/fsi/help/help40-nologo.437.1033.bsl b/tests/fsharpqa/Source/CompilerOptions/fsi/help/help40-nologo.437.1033.bsl
index 21b795880a3..971ab021d50 100644
--- a/tests/fsharpqa/Source/CompilerOptions/fsi/help/help40-nologo.437.1033.bsl
+++ b/tests/fsharpqa/Source/CompilerOptions/fsi/help/help40-nologo.437.1033.bsl
@@ -34,6 +34,9 @@ Usage: fsiAnyCpu <options> [script.fsx [<arguments>]]
 --deterministic[+|-]                     Produce a deterministic assembly
                                          (including module version GUID and
                                          timestamp)
+--realsig[+|-]                           Generate assembly with IL visibility
+                                         that matches the source code
+                                         visibility
 --pathmap:<path=sourcePath;...>          Maps physical paths to source path
                                          names output by the compiler
 --crossoptimize[+|-]                     Enable or disable cross-module
diff --git a/tests/fsharpqa/Source/CompilerOptions/fsi/help/help40.437.1033.bsl b/tests/fsharpqa/Source/CompilerOptions/fsi/help/help40.437.1033.bsl
index da80f614ab5..3f4de3d42fa 100644
--- a/tests/fsharpqa/Source/CompilerOptions/fsi/help/help40.437.1033.bsl
+++ b/tests/fsharpqa/Source/CompilerOptions/fsi/help/help40.437.1033.bsl
@@ -36,6 +36,9 @@ Usage: fsiAnyCpu <options> [script.fsx [<arguments>]]
 --deterministic[+|-]                     Produce a deterministic assembly
                                          (including module version GUID and
                                          timestamp)
+--realsig[+|-]                           Generate assembly with IL visibility
+                                         that matches the source code
+                                         visibility
 --pathmap:<path=sourcePath;...>          Maps physical paths to source path
                                          names output by the compiler
 --crossoptimize[+|-]                     Enable or disable cross-module
diff --git a/tests/service/data/SyntaxTree/String/SynExprInterpolatedStringWithTripleQuoteMultipleDollars.fs.bsl b/tests/service/data/SyntaxTree/String/SynExprInterpolatedStringWithTripleQuoteMultipleDollars.fs.bsl
index e59b33d951a..db6d4bcdc96 100644
--- a/tests/service/data/SyntaxTree/String/SynExprInterpolatedStringWithTripleQuoteMultipleDollars.fs.bsl
+++ b/tests/service/data/SyntaxTree/String/SynExprInterpolatedStringWithTripleQuoteMultipleDollars.fs.bsl
@@ -18,7 +18,7 @@ ImplFile
                   InterpolatedString
                     ([String ("1 + ", (2,8--2,21));
                       FillExpr (Const (Int32 41, (2,21--2,23)), None);
-                      String (" = ", (2,25--2,32));
+                      String (" = ", (2,23--2,32));
                       FillExpr (Const (Int32 6, (2,32--2,33)), None);
                       String (" * 7", (2,33--2,43))], TripleQuote, (2,8--2,43)),
                   (2,4--2,5), Yes (2,0--2,43), { LeadingKeyword = Let (2,0--2,3)
diff --git a/vsintegration/src/FSharp.Editor/CodeFixes/RemoveUnnecessaryParentheses.fs b/vsintegration/src/FSharp.Editor/CodeFixes/RemoveUnnecessaryParentheses.fs
index 60cbf8ccd76..b55fbb26139 100644
--- a/vsintegration/src/FSharp.Editor/CodeFixes/RemoveUnnecessaryParentheses.fs
+++ b/vsintegration/src/FSharp.Editor/CodeFixes/RemoveUnnecessaryParentheses.fs
@@ -46,60 +46,19 @@ module private Patterns =
             else
                 ValueNone
 
-        /// Trim only spaces from the start if there is something else
-        /// before the open paren on the same line (or else we could move
-        /// the whole inner expression up a line); otherwise trim all whitespace
-        // from start and end.
-        let (|Trim|) (span: TextSpan) (sourceText: SourceText) =
-            let linePosition = sourceText.Lines.GetLinePosition span.Start
-            let line = (sourceText.Lines.GetLineFromPosition span.Start).ToString()
-
-            if line.AsSpan(0, linePosition.Character).LastIndexOfAnyExcept(' ', '(') >= 0 then
-                fun (s: string) -> s.TrimEnd().TrimStart ' '
-            else
-                fun (s: string) -> s.Trim()
-
-        /// Returns the offsides diff if the given span contains an expression
-        /// whose indentation would be made invalid if the open paren
-        /// were removed (because the offside line would be shifted), e.g.,
-        ///
-        ///     // Valid.
-        ///     (let x = 2
-        ///      x)
-        ///
-        ///     // Invalid.
-        ///    ←let x = 2
-        ///      x◌
-        ///
-        ///     // Valid.
-        ///     ◌let x = 2
-        ///      x◌
-        [<return: Struct>]
-        let (|OffsidesDiff|_|) (span: TextSpan) (sourceText: SourceText) =
-            let startLinePosition = sourceText.Lines.GetLinePosition span.Start
-            let endLinePosition = sourceText.Lines.GetLinePosition span.End
-            let startLineNo = startLinePosition.Line
-            let endLineNo = endLinePosition.Line
-
-            if startLineNo = endLineNo then
-                ValueNone
-            else
-                let rec loop innerOffsides lineNo startCol =
-                    if lineNo <= endLineNo then
-                        let line = sourceText.Lines[lineNo].ToString()
+[<NoEquality; NoComparison>]
+type private InnerOffsides =
+    /// We haven't found an inner construct yet.
+    | NoneYet
 
-                        match line.AsSpan(startCol).IndexOfAnyExcept(' ', ')') with
-                        | -1 -> loop innerOffsides (lineNo + 1) 0
-                        | i -> loop (i + startCol) (lineNo + 1) 0
-                    else
-                        ValueSome(startLinePosition.Character - innerOffsides)
+    /// The start column of the first inner construct we find.
+    /// This may not be on the same line as the open paren.
+    | FirstLine of col: int
 
-                loop startLinePosition.Character startLineNo (startLinePosition.Character + 1)
-
-        let (|ShiftLeft|NoShift|ShiftRight|) n =
-            if n < 0 then ShiftLeft -n
-            elif n = 0 then NoShift
-            else ShiftRight n
+    /// The leftmost start column of an inner construct on a line
+    /// following the first inner construct we found.
+    /// We keep the first column of the first inner construct for comparison at the end.
+    | FollowingLine of firstLine: int * followingLine: int
 
 [<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.RemoveUnnecessaryParentheses); Shared; Sealed>]
 type internal FSharpRemoveUnnecessaryParenthesesCodeFixProvider [<ImportingConstructor>] () =
@@ -147,22 +106,67 @@ type internal FSharpRemoveUnnecessaryParenthesesCodeFixProvider [<ImportingConst
 
                 match firstChar, lastChar with
                 | '(', ')' ->
+                    /// Trim only spaces from the start if there is something else
+                    /// before the open paren on the same line (or else we could move
+                    /// the whole inner expression up a line); otherwise trim all whitespace
+                    /// from start and end.
+                    let (|Trim|) (sourceText: SourceText) =
+                        let linePosition = sourceText.Lines.GetLinePosition context.Span.Start
+                        let line = (sourceText.Lines.GetLineFromPosition context.Span.Start).ToString()
+
+                        if line.AsSpan(0, linePosition.Character).LastIndexOfAnyExcept(' ', '(') >= 0 then
+                            fun (s: string) -> s.TrimEnd().TrimStart ' '
+                        else
+                            fun (s: string) -> s.Trim()
+
+                    let (|ShiftLeft|NoShift|ShiftRight|) (sourceText: SourceText) =
+                        let startLinePosition = sourceText.Lines.GetLinePosition context.Span.Start
+                        let endLinePosition = sourceText.Lines.GetLinePosition context.Span.End
+                        let startLineNo = startLinePosition.Line
+                        let endLineNo = endLinePosition.Line
+
+                        if startLineNo = endLineNo then
+                            NoShift
+                        else
+                            let outerOffsides = startLinePosition.Character
+
+                            let rec loop innerOffsides lineNo startCol =
+                                if lineNo <= endLineNo then
+                                    let line = sourceText.Lines[lineNo].ToString()
+
+                                    match line.AsSpan(startCol).IndexOfAnyExcept(' ', ')') with
+                                    | -1 -> loop innerOffsides (lineNo + 1) 0
+                                    | i ->
+                                        match innerOffsides with
+                                        | NoneYet -> loop (FirstLine(i + startCol)) (lineNo + 1) 0
+                                        | FirstLine innerOffsides -> loop (FollowingLine(innerOffsides, i + startCol)) (lineNo + 1) 0
+                                        | FollowingLine(firstLine, innerOffsides) ->
+                                            loop (FollowingLine(firstLine, min innerOffsides (i + startCol))) (lineNo + 1) 0
+                                else
+                                    innerOffsides
+
+                            match loop NoneYet startLineNo (startLinePosition.Character + 1) with
+                            | NoneYet -> NoShift
+                            | FirstLine innerOffsides when innerOffsides < outerOffsides -> ShiftRight(outerOffsides - innerOffsides)
+                            | FirstLine innerOffsides -> ShiftLeft(innerOffsides - outerOffsides)
+                            | FollowingLine(firstLine, followingLine) ->
+                                match firstLine - outerOffsides with
+                                | 0 -> NoShift
+                                | 1 when firstLine < followingLine -> NoShift
+                                | primaryOffset when primaryOffset < 0 -> ShiftRight -primaryOffset
+                                | primaryOffset -> ShiftLeft primaryOffset
+
                     let adjusted =
                         match sourceText with
                         | TrailingOpen context.Span -> txt[1 .. txt.Length - 2].TrimEnd()
-
-                        | Trim context.Span trim & OffsidesDiff context.Span spaces ->
-                            match spaces with
-                            | NoShift -> trim txt[1 .. txt.Length - 2]
-                            | ShiftLeft spaces -> trim (txt[1 .. txt.Length - 2].Replace("\n" + String(' ', spaces), "\n"))
-                            | ShiftRight spaces -> trim (txt[1 .. txt.Length - 2].Replace("\n", "\n" + String(' ', spaces)))
-
-                        | _ -> txt[1 .. txt.Length - 2].Trim()
+                        | Trim trim & NoShift -> trim txt[1 .. txt.Length - 2]
+                        | Trim trim & ShiftLeft spaces -> trim (txt[1 .. txt.Length - 2].Replace("\n" + String(' ', spaces), "\n"))
+                        | Trim trim & ShiftRight spaces -> trim (txt[1 .. txt.Length - 2].Replace("\n", "\n" + String(' ', spaces)))
 
                     let newText =
                         let (|ShouldPutSpaceBefore|_|) (s: string) =
-                            // "……(……)"
-                            //  ↑↑ ↑
+                            // ……(……)
+                            // ↑↑ ↑
                             match sourceText[max (context.Span.Start - 2) 0], sourceText[max (context.Span.Start - 1) 0], s[0] with
                             | _, _, ('\n' | '\r') -> None
                             | '[', '|', (Punctuation | LetterOrDigit) -> None
@@ -178,8 +182,8 @@ type internal FSharpRemoveUnnecessaryParenthesesCodeFixProvider [<ImportingConst
                             | _ -> None
 
                         let (|ShouldPutSpaceAfter|_|) (s: string) =
-                            // "(……)…"
-                            //    ↑ ↑
+                            // (……)…
+                            //   ↑ ↑
                             match s[s.Length - 1], sourceText[min context.Span.End (sourceText.Length - 1)] with
                             | '>', ('|' | ']') -> Some ShouldPutSpaceAfter
                             | _, (')' | ']' | '[' | '}' | '.' | ';' | ',' | '|') -> None
diff --git a/vsintegration/src/FSharp.Editor/LanguageService/Tokenizer.fs b/vsintegration/src/FSharp.Editor/LanguageService/Tokenizer.fs
index f6fc4a34af3..5b873129f22 100644
--- a/vsintegration/src/FSharp.Editor/LanguageService/Tokenizer.fs
+++ b/vsintegration/src/FSharp.Editor/LanguageService/Tokenizer.fs
@@ -925,7 +925,7 @@ module internal Tokenizer =
 
         lineData, textLinePos, contents
 
-    let inline tokenizeLine (documentKey, sourceText, position, fileName, defines, langVersion, strictIndentation, cancellationToken) =
+    let tokenizeLine (documentKey, sourceText, position, fileName, defines, langVersion, strictIndentation, cancellationToken) =
         try
             let lineData, _, _ =
                 getCachedSourceLineData (
diff --git a/vsintegration/tests/FSharp.Editor.Tests/CodeFixes/CodeFixTestFramework.fs b/vsintegration/tests/FSharp.Editor.Tests/CodeFixes/CodeFixTestFramework.fs
index ca8866cda7a..1fb8d27c3a8 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/CodeFixes/CodeFixTestFramework.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/CodeFixes/CodeFixTestFramework.fs
@@ -205,13 +205,19 @@ module Xunit =
         let split (s: string) =
             s.Split([| Environment.NewLine |], StringSplitOptions.RemoveEmptyEntries)
 
-        let expected = split expected
-        let actual = split actual
+        let expectedLines = split expected
+        let actualLines = split actual
 
-        try
-            Assert.All((expected, actual) ||> Array.zip |> Array.rev, (fun (expected, actual) -> Assert.Equal(expected, actual)))
-        with :? Xunit.Sdk.AllException as all when all.Failures.Count = 1 ->
-            raise all.Failures[0]
+        if expectedLines.Length <> actualLines.Length then
+            Assert.Equal(expected, actual)
+        else
+            try
+                Assert.All(
+                    (expectedLines, actualLines) ||> Array.zip |> Array.rev,
+                    (fun (expected, actual) -> Assert.Equal(expected, actual))
+                )
+            with :? Xunit.Sdk.AllException as all when all.Failures.Count = 1 ->
+                raise all.Failures[0]
 
     /// <summary>
     /// Expects no code fix to be applied to the given code.
diff --git a/vsintegration/tests/FSharp.Editor.Tests/CodeFixes/RemoveUnnecessaryParenthesesTests.fs b/vsintegration/tests/FSharp.Editor.Tests/CodeFixes/RemoveUnnecessaryParenthesesTests.fs
index ff57ffac6d8..8808871f497 100644
--- a/vsintegration/tests/FSharp.Editor.Tests/CodeFixes/RemoveUnnecessaryParenthesesTests.fs
+++ b/vsintegration/tests/FSharp.Editor.Tests/CodeFixes/RemoveUnnecessaryParenthesesTests.fs
@@ -311,6 +311,152 @@ let _ =
             "(x) :: []", "x :: []"
             "x :: ([])", "x :: []"
 
+            """
+            let longVarName1 = 1
+            let longVarName2 = 2
+            (longFunctionName
+                longVarName1
+                longVarName2)
+            """,
+            """
+            let longVarName1 = 1
+            let longVarName2 = 2
+            longFunctionName
+                longVarName1
+                longVarName2
+            """
+
+            """
+            let longVarName1 = 1
+            let longVarName2 = 2
+            (longFunctionName
+                longVarName1
+                longVarName2
+                )
+            """,
+            """
+            let longVarName1 = 1
+            let longVarName2 = 2
+            longFunctionName
+                longVarName1
+                longVarName2
+            """
+
+            """
+            let longVarName1 = 1
+            let longVarName2 = 2
+            (longFunctionName
+                longVarName1
+                longVarName2
+            )
+            """,
+            """
+            let longVarName1 = 1
+            let longVarName2 = 2
+            longFunctionName
+                longVarName1
+                longVarName2
+            """
+
+            """
+            let longVarName1 = 1
+            let longVarName2 = 2
+            (
+                longFunctionName
+                    longVarName1
+                    longVarName2
+            )
+            """,
+            """
+            let longVarName1 = 1
+            let longVarName2 = 2
+            longFunctionName
+                longVarName1
+                longVarName2
+            """
+
+            // We could remove here, but we'd need to update
+            // the "sensitive indentation" logic to differentiate between
+            // an outer offsides column established by an open paren (as here)
+            // and an outer offsides column established by, say, the leftmost
+            // column of a binding, e.g.:
+            //
+            //     let _ = (
+            //     ↑
+            //     )
+            //
+            //     static member M () = (
+            //     ↑
+            //     )
+            """
+            let longVarName1 = 1
+            let longVarName2 = 2
+            (
+            longFunctionName
+                longVarName1
+                longVarName2
+            )
+            """,
+            """
+            let longVarName1 = 1
+            let longVarName2 = 2
+            (
+            longFunctionName
+                longVarName1
+                longVarName2
+            )
+            """
+
+            """
+            let longVarName1 = 1
+            let longVarName2 = 2
+            (
+        longFunctionName
+            longVarName1
+            longVarName2
+            )
+            """,
+            """
+            let longVarName1 = 1
+            let longVarName2 = 2
+            (
+        longFunctionName
+            longVarName1
+            longVarName2
+            )
+            """
+
+            """
+            let longVarName1 = 1
+            let longVarName2 = 2
+            (+longFunctionName
+                longVarName1
+                longVarName2)
+            """,
+            """
+            let longVarName1 = 1
+            let longVarName2 = 2
+            +longFunctionName
+                longVarName1
+                longVarName2
+            """
+
+            """
+            let longVarName1 = 1
+            let longVarName2 = 2 in (
+                longFunctionName
+                    longVarName1
+                    longVarName2
+            )
+            """,
+            """
+            let longVarName1 = 1
+            let longVarName2 = 2 in 
+                longFunctionName
+                    longVarName1
+                    longVarName2
+            """
+
             """
             let x = (printfn $"{y}"
                      2)
@@ -342,10 +488,11 @@ let _ =
             "
             let x =
              2
-             + 2
+           + 2
             in x
             "
 
+            // The extra spaces in this test are intentional.
             "
             let x =
      
@@ -361,9 +508,9 @@ let _ =
      
 
              2
-      
- 
-             + 2
+    
+
+           + 2
             in x
             "
 
@@ -398,7 +545,7 @@ let _ =
             ",
             "
             let x = 2
-                    +             2
+                  +             2
             in x
             "
 
@@ -409,7 +556,7 @@ let _ =
             ",
             "
             let x = 2
-                    + 2
+                  + 2
             in x
             "
 
@@ -420,7 +567,7 @@ let _ =
             ",
             "
             let x = x
-                    +y
+                   +y
             in x
             "
 
@@ -442,7 +589,7 @@ let _ =
             ",
             "
             let x = 2
-                    <<< 2
+                <<< 2
             in x
             "
 
@@ -455,7 +602,7 @@ in x
             "
 let (<<<<<<<<) = (<<<)
 let x = 2
-        <<<<<<<< 2
+<<<<<<<< 2
 in x
             "
 
@@ -505,7 +652,7 @@ in x
 
             let y =
                 2
-                + 2
+              + 2
 
             in x + y
             "
@@ -532,7 +679,7 @@ in x
             "
             x <
                 2
-                + 3
+              + 3
             "
 
             // LetOrUse
@@ -569,7 +716,7 @@ in x
             let x =
              ()
              2
-             ++++++ 2
+      ++++++ 2
             in x
             "
 
@@ -806,7 +953,7 @@ in x
             """
             let mutable x = 3
             x <- 3
-                 <<< 3
+             <<< 3
             """
 
             // DotIndexedGet